// $ANTLR 3.1.1 ASCollector.g3 2011-03-01 20:39:38

package actionscriptinfocollector;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;

public class ASCollectorParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AS", "BREAK", "CASE", "CATCH", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DELETE", "DO", "ELSE", "EXTENDS", "FALSE", "FINALLY", "FOR", "FUNCTION", "IF", "IMPLEMENTS", "IMPORT", "IN", "INSTANCEOF", "INTERFACE", "INTERNAL", "IS", "NATIVE", "NEW", "NULL", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SUPER", "SWITCH", "THIS", "THROW", "TO", "TRUE", "TRY", "TYPEOF", "USE", "VAR", "VOID", "WHILE", "WITH", "EACH", "GET", "SET", "NAMESPACE", "INCLUDE", "DYNAMIC", "FINAL", "OVERRIDE", "STATIC", "SEMI", "LCURLY", "RCURLY", "LPAREN", "RPAREN", "LBRACK", "RBRACK", "DOT", "COMMA", "LT", "GT", "LTE", "GTE", "EQ", "NEQ", "SAME", "NSAME", "PLUS", "SUB", "STAR", "DIV", "MOD", "INC", "DEC", "SHL", "SHR", "SHU", "AND", "OR", "XOR", "NOT", "INV", "LAND", "LOR", "QUE", "COLON", "ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "ADD_ASSIGN", "SUB_ASSIGN", "SHL_ASSIGN", "SHR_ASSIGN", "SHU_ASSIGN", "LAND_ASSIGN", "LOR_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "ELLIPSIS", "XML_ELLIPSIS", "XML_TEND", "XML_E_TEND", "XML_NS_OP", "XML_AT", "XML_LS_STD", "XML_LS_END", "UNDERSCORE", "DOLLAR", "ALPHABET", "NUMBER", "HEX_DIGIT", "CR", "LF", "UNICODE_ESCAPE", "ESCAPE_SEQUENCE", "EOL", "WHITESPACE", "COMMENT_MULTILINE", "COMMENT_SINGLELINE", "SINGLE_QUOTE_LITERAL", "DOUBLE_QUOTE_LITERAL", "REGULAR_EXPR_BODY", "REGULAR_EXPR_FLAG", "REGULAR_EXPR_LITERAL", "REGULAR_EXPR_FIRST_CHAR", "REGULAR_EXPR_CHAR", "BACKSLASH_SEQUENCE", "IDENT_PART", "HEX_NUMBER_LITERAL", "DEC_NUMBER", "EXPONENT", "DEC_NUMBER_LITERAL", "IDENT_NAME_ASCII_START", "IDENTIFIER", "IDENT_ASCII_START", "XML_COMMENT", "XML_CDATA", "XML_PI", "XML_TEXT"
    };
    public static final int PACKAGE=31;
    public static final int FUNCTION=19;
    public static final int SHR=83;
    public static final int LOR=91;
    public static final int INTERNAL=26;
    public static final int EXPONENT=139;
    public static final int LT=67;
    public static final int STAR=77;
    public static final int BACKSLASH_SEQUENCE=135;
    public static final int WHILE=47;
    public static final int MOD=79;
    public static final int SHL=82;
    public static final int CONST=9;
    public static final int MOD_ASSIGN=96;
    public static final int CASE=6;
    public static final int NEW=29;
    public static final int DO=13;
    public static final int IDENT_ASCII_START=143;
    public static final int NOT=88;
    public static final int HEX_NUMBER_LITERAL=137;
    public static final int EOF=-1;
    public static final int DIV_ASSIGN=95;
    public static final int BREAK=5;
    public static final int FINAL=55;
    public static final int RPAREN=62;
    public static final int INC=80;
    public static final int IMPORT=22;
    public static final int EOL=124;
    public static final int XML_AT=112;
    public static final int INCLUDE=53;
    public static final int THIS=38;
    public static final int RETURN=35;
    public static final int XML_PI=146;
    public static final int XML_CDATA=145;
    public static final int REGULAR_EXPR_FIRST_CHAR=133;
    public static final int IDENT_NAME_ASCII_START=141;
    public static final int GET=50;
    public static final int VAR=45;
    public static final int VOID=46;
    public static final int SUPER=36;
    public static final int EACH=49;
    public static final int EQ=71;
    public static final int SHU=84;
    public static final int RBRACK=64;
    public static final int ADD_ASSIGN=97;
    public static final int PRIVATE=32;
    public static final int STATIC=57;
    public static final int INV=89;
    public static final int SWITCH=37;
    public static final int NULL=30;
    public static final int LAND_ASSIGN=102;
    public static final int ELSE=14;
    public static final int NUMBER=118;
    public static final int DOUBLE_QUOTE_LITERAL=129;
    public static final int ELLIPSIS=107;
    public static final int NATIVE=28;
    public static final int WHITESPACE=125;
    public static final int UNDERSCORE=115;
    public static final int LCURLY=59;
    public static final int DELETE=12;
    public static final int TRY=42;
    public static final int NAMESPACE=52;
    public static final int REGULAR_EXPR_CHAR=134;
    public static final int TYPEOF=43;
    public static final int XML_LS_END=114;
    public static final int QUE=92;
    public static final int OR=86;
    public static final int IDENT_PART=136;
    public static final int GT=68;
    public static final int USE=44;
    public static final int DEC_NUMBER=138;
    public static final int CATCH=7;
    public static final int FALSE=16;
    public static final int LAND=90;
    public static final int XML_E_TEND=110;
    public static final int THROW=39;
    public static final int DYNAMIC=54;
    public static final int COMMENT_SINGLELINE=127;
    public static final int DOLLAR=116;
    public static final int PROTECTED=33;
    public static final int DEC=81;
    public static final int CLASS=8;
    public static final int LBRACK=63;
    public static final int REGULAR_EXPR_BODY=130;
    public static final int GTE=70;
    public static final int FOR=18;
    public static final int SHU_ASSIGN=101;
    public static final int SUB=76;
    public static final int AND=85;
    public static final int AND_ASSIGN=104;
    public static final int LTE=69;
    public static final int XML_LS_STD=113;
    public static final int LPAREN=61;
    public static final int SHR_ASSIGN=100;
    public static final int IF=20;
    public static final int ESCAPE_SEQUENCE=123;
    public static final int AS=4;
    public static final int XML_COMMENT=144;
    public static final int UNICODE_ESCAPE=122;
    public static final int SHL_ASSIGN=99;
    public static final int DEC_NUMBER_LITERAL=140;
    public static final int IN=23;
    public static final int IMPLEMENTS=21;
    public static final int CONTINUE=10;
    public static final int COMMA=66;
    public static final int IS=27;
    public static final int IDENTIFIER=142;
    public static final int XML_ELLIPSIS=108;
    public static final int XOR_ASSIGN=105;
    public static final int PLUS=75;
    public static final int DOT=65;
    public static final int WITH=48;
    public static final int XOR=87;
    public static final int TO=40;
    public static final int ALPHABET=117;
    public static final int DEFAULT=11;
    public static final int NSAME=74;
    public static final int REGULAR_EXPR_FLAG=131;
    public static final int HEX_DIGIT=119;
    public static final int SET=51;
    public static final int INSTANCEOF=24;
    public static final int XML_TEXT=147;
    public static final int TRUE=41;
    public static final int SEMI=58;
    public static final int SAME=73;
    public static final int COLON=93;
    public static final int OR_ASSIGN=106;
    public static final int NEQ=72;
    public static final int SINGLE_QUOTE_LITERAL=128;
    public static final int FINALLY=17;
    public static final int OVERRIDE=56;
    public static final int XML_NS_OP=111;
    public static final int RCURLY=60;
    public static final int ASSIGN=94;
    public static final int REGULAR_EXPR_LITERAL=132;
    public static final int INTERFACE=25;
    public static final int XML_TEND=109;
    public static final int DIV=78;
    public static final int CR=120;
    public static final int PUBLIC=34;
    public static final int EXTENDS=15;
    public static final int SUB_ASSIGN=98;
    public static final int COMMENT_MULTILINE=126;
    public static final int LOR_ASSIGN=103;
    public static final int LF=121;

    // delegates
    // delegators


        public ASCollectorParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public ASCollectorParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
            this.state.ruleMemo = new HashMap[547+1];
             
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return ASCollectorParser.tokenNames; }
    public String getGrammarFileName() { return "ASCollector.g3"; }


       
       		//options
    private List<Exception> mParseErrors;
    private List<ASCollector> mCreators;
    private List<ClassRecord> mClassRecordStack=new ArrayList<ClassRecord>();
    private FunctionRecord mCurrentFunction;
    private TopLevelItemRecord rec=null;
    private CommonTokenStream mRawTokens=null;
    private List<MetadataItem> mCachedMetaItems=null;
    private boolean mStopStoringBindingDecls=false;
    private boolean mSeenConditionalMemberBlock=false;
    private int mStatementDepth=0;

    public ASCollectorParser(List<ASCollector> collectors, CommonTokenStream tokenStream)
    {
    	this(tokenStream, new RecognizerSharedState());
    	mCreators=collectors;
    	mCreators.clear();
    	mRawTokens=tokenStream;
    	mStatementDepth=0;
    }

    private void addCollector()
    {
    	createCollector();	
    }

    private void createCollector()
    {
    	ASCollector newCollector=new ASCollector();
    	mCreators.add(newCollector);
    }

    private ASCollector getCollector()
    {
    	if (mCreators.size()==0)
    	{
    		createCollector();
    	}
    	return mCreators.get(mCreators.size()-1);
    }

    public boolean containsConditionalMembers()
    {
    	return mSeenConditionalMemberBlock;
    }

    private CommonTokenStream getRawTokens()
    {
    	return mRawTokens;
    }

    private void flushMetatags(TopLevelItemRecord element)
    {
    	if (mCachedMetaItems!=null)
    	{
    		element.addMetadataItems(mCachedMetaItems);
    		mCachedMetaItems=null;
    	}
    }

    private void addMetadataItem(MetadataItem item)
    {
    	if (mCachedMetaItems==null)
    	{
    		mCachedMetaItems=new ArrayList<MetadataItem>();
    	}
    	
    	if (getFunctionRecord()!=null)
    		return;
    	
    	mCachedMetaItems.add(item);
    }

    public boolean foundNextLT()
    {
       int i=1;
       while (true)
       {
           Token token=input.LT(i);
           if (token.getText()!=null && token.getText().startsWith("<"))
              return (i>1);
           if (token.getType()==EOF)
              return false;
           i++;   
       }
    }

    public void changeTokensUpToNextLT()
    {
       int i=1;
       while (true)
       {
           Token t=input.LT(i);
           if (t.getText()!=null && t.getText().startsWith("<"))
              return;
           if (t.getType()==EOF)
              return;
           t.setType(XML_TEXT);          
              
           i++;   
       }
    }


        public boolean findVirtualHiddenToken(ParserRuleReturnScope retval)
        {
        		//the point of this method is to look for something that can serve as a semicolon.  So a carriage return
        		//or a comment containing a carriage return will fit the bill.
                int index = retval.start.getTokenIndex();
                if(index<0){
                    index = input.size();
                }
                else
                {
                	Token lt=input.get(index);
                	if (lt.getType()==EOF || lt.getType()==SEMI || lt.getType()==RCURLY)
                		return false;
                }
                
    /*            //we are on the next regular channel token after the rule.  So we walk backward to determine if between
                //the rule and this token is a single line comment, multiline comment, or new line that can serve as the
                //end token.  If so, then we 'promote' that token by returning it as the 'end' token of the rule (in place
                //of the semi colon).
    	        for (int ix = index - 1; ix >= 0; ix--){
    	            Token lt = input.get(ix);
    	            int type = lt.getType();
    	            if(lt.getChannel() == Token.DEFAULT_CHANNEL)
    	                break;
    	            if (type == EOL || type==COMMENT_SINGLELINE || (type == COMMENT_MULTILINE && lt.getText().matches("/.*\r\n|\r|\n")))
    	            {
    	            	retval.start=lt;
    	                return true;
    	            }
    	        }*/
                
                
                //the token index is pointing to the next default channel token, which is not what we want.
                //We want to walk backward to the previous default channel token (first loop), and then walk forward
                //again looking for EOL/comments (2nd loop)
                int ix=index-1;
                for (; ix >= 0; ix--){
                    Token lt = input.get(ix);
                    if(lt.getChannel() == Token.DEFAULT_CHANNEL)
                        break;
                }
                
                //walk forward again
                ix++; //to move to next token that's not default channel
                for (;ix<input.size();ix++) //now search for the next "statement ender"
                {
                    Token lt = input.get(ix);
                    int type = lt.getType();
                    if (lt.getChannel() == Token.DEFAULT_CHANNEL)
                        break;
                    if (type == EOL || type==COMMENT_SINGLELINE || (type == COMMENT_MULTILINE && lt.getText().matches("/.*\r\n|\r|\n")))
                    {
                    	retval.start=lt;
                        return true;
                    }
                }

                return false;

        }

    public void reportError(RecognitionException e)
    {
        if (mParseErrors==null)
        	mParseErrors=new ArrayList<Exception>();
        mParseErrors.add(e);
        super.reportError(e);
    }
    	
    public List<Exception> getParseErrors()
    {
        return mParseErrors;
    }
        
        public static final int CHANNEL_SLCOMMENT=43;
        public static final int CHANNEL_MLCOMMENT=42;
        public static final int CHANNEL_WHITESPACE=41;
        public static final int CHANNEL_EOL=40;
        private final boolean promoteWhitespace()
        {
        	//find the current lookahead token
            Token lt = input.LT(1);
            int index = lt.getTokenIndex();
            if(index<0){
                index = input.size();
            }

    		//walk backward through tokens to see if the previous token is whitespace.
            for (int ix = index - 1; ix >= 0; ix--){
                lt = input.get(ix);
                int channel=lt.getChannel();
                if (channel == CHANNEL_EOL || channel ==  CHANNEL_WHITESPACE){
                    return true;
                } else if(channel == Token.DEFAULT_CHANNEL){
                    break;
                }
            }
            return false;
        }
        
        private FunctionRecord getFunctionRecord()
        {
        	return mCurrentFunction;
        }
        
        private TopLevelItemRecord mCurrentItem;
        private void setCurrentItem(TopLevelItemRecord rec)
        {
        	mCurrentItem=rec;
        }
        
        private ParserTextHandler mTextHandler;
        
        private void setTextHandler(ParserTextHandler handler)
        {
        	mTextHandler=handler;
        }
        
        private ParserTextHandler getTextHandler()
        {
        	return mTextHandler;
        }
        
        private void clearTextHandler()
        {
        	mTextHandler=null;
        }
        
        private void setCurrentFunction(FunctionRecord func)
        {
        	mCurrentFunction=func;
        }
        
        private void createClassRecord()
        {
        	ClassRecord record=new ClassRecord();
        	mClassRecordStack.add(record);
        }
     
        private void capturePostHiddenTokens(SourceItem item, Token t)
        {
        	item.addPostTokens(AntlrUtilities.getPostHiddenTokens(t, getRawTokens()));
        }
        
        private void capturePostHiddenTokens(SourceItem item, ParserRuleReturnScope t)
        {
        	item.addPostTokens(AntlrUtilities.getPostHiddenTokens(t, getRawTokens()));
        }
        
        private void captureHiddenTokens(SourceItem item, Token t)
        {
        	item.addPreTokens(AntlrUtilities.getHiddenTokens(t, getRawTokens(), item instanceof ISourceElement, false));
        }
        
        private void captureHiddenTokens(SourceItem item, ParserRuleReturnScope t)
        {
        	item.addPreTokens(AntlrUtilities.getHiddenTokens(t, getRawTokens(), item instanceof ISourceElement));
        }
        
        private void closeClassRecord()
        {
        	if (mClassRecordStack.size()>0)
        	{
        		ClassRecord rec=mClassRecordStack.remove(mClassRecordStack.size()-1);
        		getCollector().addClass(rec);
        	}
        }
        
        private ClassRecord getClassRecord()
        {
        	if (mClassRecordStack.size()==0)
        		return null;
        	return mClassRecordStack.get(mClassRecordStack.size()-1);
        }
        
        


    public static class booleanLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "booleanLiteral"
    // ASCollector.g3:835:1: booleanLiteral : (T= TRUE | F= FALSE );
    public final ASCollectorParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
        ASCollectorParser.booleanLiteral_return retval = new ASCollectorParser.booleanLiteral_return();
        retval.start = input.LT(1);
        int booleanLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token T=null;
        Token F=null;

        Object T_tree=null;
        Object F_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }
            // ASCollector.g3:835:36: (T= TRUE | F= FALSE )
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0==TRUE) ) {
                alt1=1;
            }
            else if ( (LA1_0==FALSE) ) {
                alt1=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // ASCollector.g3:835:40: T= TRUE
                    {
                    root_0 = (Object)adaptor.nil();

                    T=(Token)match(input,TRUE,FOLLOW_TRUE_in_booleanLiteral3641); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    T_tree = (Object)adaptor.create(T);
                    adaptor.addChild(root_0, T_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:835:49: F= FALSE
                    {
                    root_0 = (Object)adaptor.nil();

                    F=(Token)match(input,FALSE,FOLLOW_FALSE_in_booleanLiteral3647); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    F_tree = (Object)adaptor.create(F);
                    adaptor.addChild(root_0, F_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 1, booleanLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "booleanLiteral"

    public static class numericLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "numericLiteral"
    // ASCollector.g3:837:1: numericLiteral : (D= DEC_NUMBER_LITERAL | H= HEX_NUMBER_LITERAL );
    public final ASCollectorParser.numericLiteral_return numericLiteral() throws RecognitionException {
        ASCollectorParser.numericLiteral_return retval = new ASCollectorParser.numericLiteral_return();
        retval.start = input.LT(1);
        int numericLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token D=null;
        Token H=null;

        Object D_tree=null;
        Object H_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }
            // ASCollector.g3:837:36: (D= DEC_NUMBER_LITERAL | H= HEX_NUMBER_LITERAL )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==DEC_NUMBER_LITERAL) ) {
                alt2=1;
            }
            else if ( (LA2_0==HEX_NUMBER_LITERAL) ) {
                alt2=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // ASCollector.g3:837:40: D= DEC_NUMBER_LITERAL
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DEC_NUMBER_LITERAL,FOLLOW_DEC_NUMBER_LITERAL_in_numericLiteral3679); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:837:63: H= HEX_NUMBER_LITERAL
                    {
                    root_0 = (Object)adaptor.nil();

                    H=(Token)match(input,HEX_NUMBER_LITERAL,FOLLOW_HEX_NUMBER_LITERAL_in_numericLiteral3685); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    H_tree = (Object)adaptor.create(H);
                    adaptor.addChild(root_0, H_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 2, numericLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "numericLiteral"

    public static class stringLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "stringLiteral"
    // ASCollector.g3:839:1: stringLiteral : (S= SINGLE_QUOTE_LITERAL | D= DOUBLE_QUOTE_LITERAL );
    public final ASCollectorParser.stringLiteral_return stringLiteral() throws RecognitionException {
        ASCollectorParser.stringLiteral_return retval = new ASCollectorParser.stringLiteral_return();
        retval.start = input.LT(1);
        int stringLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token S=null;
        Token D=null;

        Object S_tree=null;
        Object D_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }
            // ASCollector.g3:839:36: (S= SINGLE_QUOTE_LITERAL | D= DOUBLE_QUOTE_LITERAL )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==SINGLE_QUOTE_LITERAL) ) {
                alt3=1;
            }
            else if ( (LA3_0==DOUBLE_QUOTE_LITERAL) ) {
                alt3=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // ASCollector.g3:839:40: S= SINGLE_QUOTE_LITERAL
                    {
                    root_0 = (Object)adaptor.nil();

                    S=(Token)match(input,SINGLE_QUOTE_LITERAL,FOLLOW_SINGLE_QUOTE_LITERAL_in_stringLiteral3718); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:839:65: D= DOUBLE_QUOTE_LITERAL
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DOUBLE_QUOTE_LITERAL,FOLLOW_DOUBLE_QUOTE_LITERAL_in_stringLiteral3724); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 3, stringLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "stringLiteral"

    public static class regularExpresionLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "regularExpresionLiteral"
    // ASCollector.g3:841:1: regularExpresionLiteral : R= REGULAR_EXPR_LITERAL ;
    public final ASCollectorParser.regularExpresionLiteral_return regularExpresionLiteral() throws RecognitionException {
        ASCollectorParser.regularExpresionLiteral_return retval = new ASCollectorParser.regularExpresionLiteral_return();
        retval.start = input.LT(1);
        int regularExpresionLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token R=null;

        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }
            // ASCollector.g3:841:36: (R= REGULAR_EXPR_LITERAL )
            // ASCollector.g3:841:40: R= REGULAR_EXPR_LITERAL
            {
            root_0 = (Object)adaptor.nil();

            R=(Token)match(input,REGULAR_EXPR_LITERAL,FOLLOW_REGULAR_EXPR_LITERAL_in_regularExpresionLiteral3748); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 4, regularExpresionLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "regularExpresionLiteral"

    public static class identifierLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "identifierLiteral"
    // ASCollector.g3:843:1: identifierLiteral : (I= IDENTIFIER | notQuiteReservedWord );
    public final ASCollectorParser.identifierLiteral_return identifierLiteral() throws RecognitionException {
        ASCollectorParser.identifierLiteral_return retval = new ASCollectorParser.identifierLiteral_return();
        retval.start = input.LT(1);
        int identifierLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        ASCollectorParser.notQuiteReservedWord_return notQuiteReservedWord1 = null;


        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }
            // ASCollector.g3:843:36: (I= IDENTIFIER | notQuiteReservedWord )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==IDENTIFIER) ) {
                alt4=1;
            }
            else if ( (LA4_0==NATIVE||LA4_0==TO||(LA4_0>=EACH && LA4_0<=NAMESPACE)||(LA4_0>=DYNAMIC && LA4_0<=STATIC)) ) {
                alt4=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // ASCollector.g3:843:88: I= IDENTIFIER
                    {
                    root_0 = (Object)adaptor.nil();

                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierLiteral3780); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:843:103: notQuiteReservedWord
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_notQuiteReservedWord_in_identifierLiteral3784);
                    notQuiteReservedWord1=notQuiteReservedWord();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, notQuiteReservedWord1.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 5, identifierLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "identifierLiteral"

    public static class xmlNameLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlNameLiteral"
    // ASCollector.g3:845:1: xmlNameLiteral : ( IDENTIFIER | allKeywords ) ({...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords ) )* ;
    public final ASCollectorParser.xmlNameLiteral_return xmlNameLiteral() throws RecognitionException {
        ASCollectorParser.xmlNameLiteral_return retval = new ASCollectorParser.xmlNameLiteral_return();
        retval.start = input.LT(1);
        int xmlNameLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token IDENTIFIER2=null;
        Token set4=null;
        Token IDENTIFIER5=null;
        ASCollectorParser.allKeywords_return allKeywords3 = null;

        ASCollectorParser.allKeywords_return allKeywords6 = null;


        Object IDENTIFIER2_tree=null;
        Object set4_tree=null;
        Object IDENTIFIER5_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }
            // ASCollector.g3:845:36: ( ( IDENTIFIER | allKeywords ) ({...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords ) )* )
            // ASCollector.g3:845:40: ( IDENTIFIER | allKeywords ) ({...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords ) )*
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:845:40: ( IDENTIFIER | allKeywords )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==IDENTIFIER) ) {
                alt5=1;
            }
            else if ( ((LA5_0>=AS && LA5_0<=STATIC)) ) {
                alt5=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // ASCollector.g3:845:41: IDENTIFIER
                    {
                    IDENTIFIER2=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_xmlNameLiteral3817); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER2_tree = (Object)adaptor.create(IDENTIFIER2);
                    adaptor.addChild(root_0, IDENTIFIER2_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:845:54: allKeywords
                    {
                    pushFollow(FOLLOW_allKeywords_in_xmlNameLiteral3821);
                    allKeywords3=allKeywords();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, allKeywords3.getTree());

                    }
                    break;

            }

            // ASCollector.g3:845:67: ({...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords ) )*
            loop7:
            do {
                int alt7=2;
                alt7 = dfa7.predict(input);
                switch (alt7) {
            	case 1 :
            	    // ASCollector.g3:845:69: {...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords )
            	    {
            	    if ( !((!promoteWhitespace())) ) {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        throw new FailedPredicateException(input, "xmlNameLiteral", "!promoteWhitespace()");
            	    }
            	    set4=(Token)input.LT(1);
            	    if ( input.LA(1)==DOT||input.LA(1)==SUB||input.LA(1)==COLON ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set4));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	    if ( !((!promoteWhitespace())) ) {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        throw new FailedPredicateException(input, "xmlNameLiteral", "!promoteWhitespace()");
            	    }
            	    // ASCollector.g3:845:141: ( IDENTIFIER | allKeywords )
            	    int alt6=2;
            	    int LA6_0 = input.LA(1);

            	    if ( (LA6_0==IDENTIFIER) ) {
            	        alt6=1;
            	    }
            	    else if ( ((LA6_0>=AS && LA6_0<=STATIC)) ) {
            	        alt6=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 6, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt6) {
            	        case 1 :
            	            // ASCollector.g3:845:142: IDENTIFIER
            	            {
            	            IDENTIFIER5=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_xmlNameLiteral3845); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            IDENTIFIER5_tree = (Object)adaptor.create(IDENTIFIER5);
            	            adaptor.addChild(root_0, IDENTIFIER5_tree);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // ASCollector.g3:845:155: allKeywords
            	            {
            	            pushFollow(FOLLOW_allKeywords_in_xmlNameLiteral3849);
            	            allKeywords6=allKeywords();

            	            state._fsp--;
            	            if (state.failed) return retval;
            	            if ( state.backtracking==0 ) adaptor.addChild(root_0, allKeywords6.getTree());

            	            }
            	            break;

            	    }


            	    }
            	    break;

            	default :
            	    break loop7;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 6, xmlNameLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlNameLiteral"

    public static class literal_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "literal"
    // ASCollector.g3:848:1: literal : (N= NULL | booleanLiteral | numericLiteral | stringLiteral | regularExpresionLiteral );
    public final ASCollectorParser.literal_return literal() throws RecognitionException {
        ASCollectorParser.literal_return retval = new ASCollectorParser.literal_return();
        retval.start = input.LT(1);
        int literal_StartIndex = input.index();
        Object root_0 = null;

        Token N=null;
        ASCollectorParser.booleanLiteral_return booleanLiteral7 = null;

        ASCollectorParser.numericLiteral_return numericLiteral8 = null;

        ASCollectorParser.stringLiteral_return stringLiteral9 = null;

        ASCollectorParser.regularExpresionLiteral_return regularExpresionLiteral10 = null;


        Object N_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }
            // ASCollector.g3:848:36: (N= NULL | booleanLiteral | numericLiteral | stringLiteral | regularExpresionLiteral )
            int alt8=5;
            switch ( input.LA(1) ) {
            case NULL:
                {
                alt8=1;
                }
                break;
            case FALSE:
            case TRUE:
                {
                alt8=2;
                }
                break;
            case HEX_NUMBER_LITERAL:
            case DEC_NUMBER_LITERAL:
                {
                alt8=3;
                }
                break;
            case SINGLE_QUOTE_LITERAL:
            case DOUBLE_QUOTE_LITERAL:
                {
                alt8=4;
                }
                break;
            case REGULAR_EXPR_LITERAL:
                {
                alt8=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }

            switch (alt8) {
                case 1 :
                    // ASCollector.g3:848:40: N= NULL
                    {
                    root_0 = (Object)adaptor.nil();

                    N=(Token)match(input,NULL,FOLLOW_NULL_in_literal3902); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    N_tree = (Object)adaptor.create(N);
                    adaptor.addChild(root_0, N_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:848:50: booleanLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_booleanLiteral_in_literal3907);
                    booleanLiteral7=booleanLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, booleanLiteral7.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:848:67: numericLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_numericLiteral_in_literal3911);
                    numericLiteral8=numericLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, numericLiteral8.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:848:84: stringLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_stringLiteral_in_literal3915);
                    stringLiteral9=stringLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, stringLiteral9.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:848:100: regularExpresionLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_regularExpresionLiteral_in_literal3919);
                    regularExpresionLiteral10=regularExpresionLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, regularExpresionLiteral10.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 7, literal_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "literal"

    public static class xmlMarkup_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlMarkup"
    // ASCollector.g3:851:1: xmlMarkup : ( xmlComment | xmlCDATA | xmlPI );
    public final ASCollectorParser.xmlMarkup_return xmlMarkup() throws RecognitionException {
        ASCollectorParser.xmlMarkup_return retval = new ASCollectorParser.xmlMarkup_return();
        retval.start = input.LT(1);
        int xmlMarkup_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlComment_return xmlComment11 = null;

        ASCollectorParser.xmlCDATA_return xmlCDATA12 = null;

        ASCollectorParser.xmlPI_return xmlPI13 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }
            // ASCollector.g3:851:36: ( xmlComment | xmlCDATA | xmlPI )
            int alt9=3;
            switch ( input.LA(1) ) {
            case XML_COMMENT:
                {
                alt9=1;
                }
                break;
            case XML_CDATA:
                {
                alt9=2;
                }
                break;
            case XML_PI:
                {
                alt9=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }

            switch (alt9) {
                case 1 :
                    // ASCollector.g3:851:40: xmlComment
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlComment_in_xmlMarkup3955);
                    xmlComment11=xmlComment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlComment11.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:851:53: xmlCDATA
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlCDATA_in_xmlMarkup3959);
                    xmlCDATA12=xmlCDATA();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlCDATA12.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:851:64: xmlPI
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlPI_in_xmlMarkup3963);
                    xmlPI13=xmlPI();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPI13.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 8, xmlMarkup_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlMarkup"

    public static class xmlComment_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlComment"
    // ASCollector.g3:852:1: xmlComment : x= XML_COMMENT ;
    public final ASCollectorParser.xmlComment_return xmlComment() throws RecognitionException {
        ASCollectorParser.xmlComment_return retval = new ASCollectorParser.xmlComment_return();
        retval.start = input.LT(1);
        int xmlComment_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;

        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }
            // ASCollector.g3:852:36: (x= XML_COMMENT )
            // ASCollector.g3:852:40: x= XML_COMMENT
            {
            root_0 = (Object)adaptor.nil();

            x=(Token)match(input,XML_COMMENT,FOLLOW_XML_COMMENT_in_xmlComment3998); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 9, xmlComment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlComment"

    public static class xmlCDATA_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlCDATA"
    // ASCollector.g3:853:1: xmlCDATA : x= XML_CDATA ;
    public final ASCollectorParser.xmlCDATA_return xmlCDATA() throws RecognitionException {
        ASCollectorParser.xmlCDATA_return retval = new ASCollectorParser.xmlCDATA_return();
        retval.start = input.LT(1);
        int xmlCDATA_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;

        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; }
            // ASCollector.g3:853:36: (x= XML_CDATA )
            // ASCollector.g3:853:40: x= XML_CDATA
            {
            root_0 = (Object)adaptor.nil();

            x=(Token)match(input,XML_CDATA,FOLLOW_XML_CDATA_in_xmlCDATA4039); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 10, xmlCDATA_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlCDATA"

    public static class xmlPI_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlPI"
    // ASCollector.g3:854:1: xmlPI : x= XML_PI ;
    public final ASCollectorParser.xmlPI_return xmlPI() throws RecognitionException {
        ASCollectorParser.xmlPI_return retval = new ASCollectorParser.xmlPI_return();
        retval.start = input.LT(1);
        int xmlPI_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;

        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return retval; }
            // ASCollector.g3:854:36: (x= XML_PI )
            // ASCollector.g3:854:40: x= XML_PI
            {
            root_0 = (Object)adaptor.nil();

            x=(Token)match(input,XML_PI,FOLLOW_XML_PI_in_xmlPI4081); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 11, xmlPI_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlPI"

    public static class xmlExprEval_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlExprEval"
    // ASCollector.g3:855:1: xmlExprEval : L= LCURLY expression R= RCURLY ;
    public final ASCollectorParser.xmlExprEval_return xmlExprEval() throws RecognitionException {
        ASCollectorParser.xmlExprEval_return retval = new ASCollectorParser.xmlExprEval_return();
        retval.start = input.LT(1);
        int xmlExprEval_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.expression_return expression14 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return retval; }
            // ASCollector.g3:855:36: (L= LCURLY expression R= RCURLY )
            // ASCollector.g3:855:40: L= LCURLY expression R= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_xmlExprEval4118); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_expression_in_xmlExprEval4121);
            expression14=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression14.getTree());
            R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_xmlExprEval4125); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 12, xmlExprEval_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlExprEval"

    public static class xmlTextElement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlTextElement"
    // ASCollector.g3:858:1: xmlTextElement : ( allKeywords | lexToken= ( DEC_NUMBER_LITERAL | HEX_NUMBER_LITERAL | SINGLE_QUOTE_LITERAL | DOUBLE_QUOTE_LITERAL | IDENTIFIER | XML_TEXT | DIV | SEMI | RCURLY | LPAREN | RPAREN | LBRACK | RBRACK | DOT | COMMA | GT | LTE | EQ | NEQ | SAME | NSAME | PLUS | SUB | STAR | MOD | INC | DEC | SHL | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | LOR_ASSIGN | LAND_ASSIGN | ELLIPSIS | XML_ELLIPSIS | XML_NS_OP | XML_AT ) );
    public final ASCollectorParser.xmlTextElement_return xmlTextElement() throws RecognitionException {
        ASCollectorParser.xmlTextElement_return retval = new ASCollectorParser.xmlTextElement_return();
        retval.start = input.LT(1);
        int xmlTextElement_StartIndex = input.index();
        Object root_0 = null;

        Token lexToken=null;
        ASCollectorParser.allKeywords_return allKeywords15 = null;


        Object lexToken_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return retval; }
            // ASCollector.g3:859:5: ( allKeywords | lexToken= ( DEC_NUMBER_LITERAL | HEX_NUMBER_LITERAL | SINGLE_QUOTE_LITERAL | DOUBLE_QUOTE_LITERAL | IDENTIFIER | XML_TEXT | DIV | SEMI | RCURLY | LPAREN | RPAREN | LBRACK | RBRACK | DOT | COMMA | GT | LTE | EQ | NEQ | SAME | NSAME | PLUS | SUB | STAR | MOD | INC | DEC | SHL | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | LOR_ASSIGN | LAND_ASSIGN | ELLIPSIS | XML_ELLIPSIS | XML_NS_OP | XML_AT ) )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( ((LA10_0>=AS && LA10_0<=STATIC)) ) {
                alt10=1;
            }
            else if ( (LA10_0==SEMI||(LA10_0>=RCURLY && LA10_0<=COMMA)||(LA10_0>=GT && LA10_0<=LTE)||(LA10_0>=EQ && LA10_0<=SHL)||(LA10_0>=AND && LA10_0<=SHL_ASSIGN)||(LA10_0>=LAND_ASSIGN && LA10_0<=XML_ELLIPSIS)||(LA10_0>=XML_NS_OP && LA10_0<=XML_AT)||(LA10_0>=SINGLE_QUOTE_LITERAL && LA10_0<=DOUBLE_QUOTE_LITERAL)||LA10_0==HEX_NUMBER_LITERAL||LA10_0==DEC_NUMBER_LITERAL||LA10_0==IDENTIFIER||LA10_0==XML_TEXT) ) {
                alt10=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }
            switch (alt10) {
                case 1 :
                    // ASCollector.g3:860:3: allKeywords
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_allKeywords_in_xmlTextElement4142);
                    allKeywords15=allKeywords();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, allKeywords15.getTree());
                    if ( state.backtracking==0 ) {
                      /*TODO: see if I can change token type*/
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:861:7: lexToken= ( DEC_NUMBER_LITERAL | HEX_NUMBER_LITERAL | SINGLE_QUOTE_LITERAL | DOUBLE_QUOTE_LITERAL | IDENTIFIER | XML_TEXT | DIV | SEMI | RCURLY | LPAREN | RPAREN | LBRACK | RBRACK | DOT | COMMA | GT | LTE | EQ | NEQ | SAME | NSAME | PLUS | SUB | STAR | MOD | INC | DEC | SHL | AND | OR | XOR | NOT | INV | LAND | LOR | QUE | COLON | ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | LOR_ASSIGN | LAND_ASSIGN | ELLIPSIS | XML_ELLIPSIS | XML_NS_OP | XML_AT )
                    {
                    root_0 = (Object)adaptor.nil();

                    lexToken=(Token)input.LT(1);
                    if ( input.LA(1)==SEMI||(input.LA(1)>=RCURLY && input.LA(1)<=COMMA)||(input.LA(1)>=GT && input.LA(1)<=LTE)||(input.LA(1)>=EQ && input.LA(1)<=SHL)||(input.LA(1)>=AND && input.LA(1)<=SHL_ASSIGN)||(input.LA(1)>=LAND_ASSIGN && input.LA(1)<=XML_ELLIPSIS)||(input.LA(1)>=XML_NS_OP && input.LA(1)<=XML_AT)||(input.LA(1)>=SINGLE_QUOTE_LITERAL && input.LA(1)<=DOUBLE_QUOTE_LITERAL)||input.LA(1)==HEX_NUMBER_LITERAL||input.LA(1)==DEC_NUMBER_LITERAL||input.LA(1)==IDENTIFIER||input.LA(1)==XML_TEXT ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(lexToken));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }

                    if ( state.backtracking==0 ) {

                              lexToken.setType(XML_TEXT); 
                          
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 13, xmlTextElement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlTextElement"

    public static class xmlText_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlText"
    // ASCollector.g3:932:1: xmlText : (x= XML_TEXT | xmlTextElement )+ ;
    public final ASCollectorParser.xmlText_return xmlText() throws RecognitionException {
        ASCollectorParser.xmlText_return retval = new ASCollectorParser.xmlText_return();
        retval.start = input.LT(1);
        int xmlText_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;
        ASCollectorParser.xmlTextElement_return xmlTextElement16 = null;


        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return retval; }
            // ASCollector.g3:937:5: ( (x= XML_TEXT | xmlTextElement )+ )
            // ASCollector.g3:939:5: (x= XML_TEXT | xmlTextElement )+
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:939:5: (x= XML_TEXT | xmlTextElement )+
            int cnt11=0;
            loop11:
            do {
                int alt11=3;
                switch ( input.LA(1) ) {
                case XML_TEXT:
                    {
                    int LA11_2 = input.LA(2);

                    if ( (synpred68_ASCollector()) ) {
                        alt11=1;
                    }
                    else if ( (synpred69_ASCollector()) ) {
                        alt11=2;
                    }


                    }
                    break;
                case AS:
                case BREAK:
                case CASE:
                case CATCH:
                case CLASS:
                case CONST:
                case CONTINUE:
                case DEFAULT:
                case DELETE:
                case DO:
                case ELSE:
                case EXTENDS:
                case FALSE:
                case FINALLY:
                case FOR:
                case FUNCTION:
                case IF:
                case IMPLEMENTS:
                case IMPORT:
                case IN:
                case INSTANCEOF:
                case INTERFACE:
                case INTERNAL:
                case IS:
                case NEW:
                case NULL:
                case PACKAGE:
                case PRIVATE:
                case PROTECTED:
                case PUBLIC:
                case RETURN:
                case SUPER:
                case SWITCH:
                case THIS:
                case THROW:
                case TRUE:
                case TRY:
                case TYPEOF:
                case USE:
                case VAR:
                case VOID:
                case WHILE:
                case WITH:
                case INCLUDE:
                    {
                    int LA11_3 = input.LA(2);

                    if ( (synpred69_ASCollector()) ) {
                        alt11=2;
                    }


                    }
                    break;
                case NATIVE:
                case TO:
                case EACH:
                case GET:
                case SET:
                case NAMESPACE:
                case DYNAMIC:
                case FINAL:
                case OVERRIDE:
                case STATIC:
                    {
                    int LA11_4 = input.LA(2);

                    if ( (synpred69_ASCollector()) ) {
                        alt11=2;
                    }


                    }
                    break;
                case SEMI:
                case RCURLY:
                case LPAREN:
                case RPAREN:
                case LBRACK:
                case RBRACK:
                case DOT:
                case COMMA:
                case GT:
                case LTE:
                case EQ:
                case NEQ:
                case SAME:
                case NSAME:
                case PLUS:
                case SUB:
                case STAR:
                case DIV:
                case MOD:
                case INC:
                case DEC:
                case SHL:
                case AND:
                case OR:
                case XOR:
                case NOT:
                case INV:
                case LAND:
                case LOR:
                case QUE:
                case COLON:
                case ASSIGN:
                case DIV_ASSIGN:
                case MOD_ASSIGN:
                case ADD_ASSIGN:
                case SUB_ASSIGN:
                case SHL_ASSIGN:
                case LAND_ASSIGN:
                case LOR_ASSIGN:
                case AND_ASSIGN:
                case XOR_ASSIGN:
                case OR_ASSIGN:
                case ELLIPSIS:
                case XML_ELLIPSIS:
                case XML_NS_OP:
                case XML_AT:
                case SINGLE_QUOTE_LITERAL:
                case DOUBLE_QUOTE_LITERAL:
                case HEX_NUMBER_LITERAL:
                case DEC_NUMBER_LITERAL:
                case IDENTIFIER:
                    {
                    int LA11_5 = input.LA(2);

                    if ( (synpred69_ASCollector()) ) {
                        alt11=2;
                    }


                    }
                    break;

                }

                switch (alt11) {
            	case 1 :
            	    // ASCollector.g3:939:6: x= XML_TEXT
            	    {
            	    x=(Token)match(input,XML_TEXT,FOLLOW_XML_TEXT_in_xmlText4878); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    x_tree = (Object)adaptor.create(x);
            	    adaptor.addChild(root_0, x_tree);
            	    }

            	    }
            	    break;
            	case 2 :
            	    // ASCollector.g3:939:20: xmlTextElement
            	    {
            	    pushFollow(FOLLOW_xmlTextElement_in_xmlText4883);
            	    xmlTextElement16=xmlTextElement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlTextElement16.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt11 >= 1 ) break loop11;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(11, input);
                        throw eee;
                }
                cnt11++;
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
            if ( state.backtracking==0 ) {

                  System.out.println("xmlText.text=("+input.toString(retval.start,input.LT(-1))+")");
                  System.out.println("xmlText after start currentIndex = "+input.index()+"size = "+input.size());

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 14, xmlText_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlText"

    public static class xmlPrimaryExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlPrimaryExpression"
    // ASCollector.g3:943:1: xmlPrimaryExpression : ( xmlPropertyIdentifier | xmlInitialiser | xmlListInitialiser );
    public final ASCollectorParser.xmlPrimaryExpression_return xmlPrimaryExpression() throws RecognitionException {
        ASCollectorParser.xmlPrimaryExpression_return retval = new ASCollectorParser.xmlPrimaryExpression_return();
        retval.start = input.LT(1);
        int xmlPrimaryExpression_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlPropertyIdentifier_return xmlPropertyIdentifier17 = null;

        ASCollectorParser.xmlInitialiser_return xmlInitialiser18 = null;

        ASCollectorParser.xmlListInitialiser_return xmlListInitialiser19 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return retval; }
            // ASCollector.g3:944:5: ( xmlPropertyIdentifier | xmlInitialiser | xmlListInitialiser )
            int alt12=3;
            switch ( input.LA(1) ) {
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NATIVE:
            case NEW:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TO:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case INCLUDE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case STAR:
            case XML_AT:
            case IDENTIFIER:
                {
                alt12=1;
                }
                break;
            case LT:
            case XML_COMMENT:
            case XML_CDATA:
            case XML_PI:
                {
                alt12=2;
                }
                break;
            case XML_LS_STD:
                {
                alt12=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }

            switch (alt12) {
                case 1 :
                    // ASCollector.g3:944:9: xmlPropertyIdentifier
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlPropertyIdentifier_in_xmlPrimaryExpression4907);
                    xmlPropertyIdentifier17=xmlPropertyIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPropertyIdentifier17.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:945:9: xmlInitialiser
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlInitialiser_in_xmlPrimaryExpression4917);
                    xmlInitialiser18=xmlInitialiser();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlInitialiser18.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:946:9: xmlListInitialiser
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlListInitialiser_in_xmlPrimaryExpression4927);
                    xmlListInitialiser19=xmlListInitialiser();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlListInitialiser19.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 15, xmlPrimaryExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlPrimaryExpression"

    public static class xmlPropertyIdentifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlPropertyIdentifier"
    // ASCollector.g3:959:1: xmlPropertyIdentifier : ( xmlAttributeIdentifier | xmlQualifiedIdentifier | s= STAR );
    public final ASCollectorParser.xmlPropertyIdentifier_return xmlPropertyIdentifier() throws RecognitionException {
        ASCollectorParser.xmlPropertyIdentifier_return retval = new ASCollectorParser.xmlPropertyIdentifier_return();
        retval.start = input.LT(1);
        int xmlPropertyIdentifier_StartIndex = input.index();
        Object root_0 = null;

        Token s=null;
        ASCollectorParser.xmlAttributeIdentifier_return xmlAttributeIdentifier20 = null;

        ASCollectorParser.xmlQualifiedIdentifier_return xmlQualifiedIdentifier21 = null;


        Object s_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return retval; }
            // ASCollector.g3:960:7: ( xmlAttributeIdentifier | xmlQualifiedIdentifier | s= STAR )
            int alt13=3;
            switch ( input.LA(1) ) {
            case XML_AT:
                {
                alt13=1;
                }
                break;
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NATIVE:
            case NEW:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TO:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case INCLUDE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case IDENTIFIER:
                {
                alt13=2;
                }
                break;
            case STAR:
                {
                int LA13_5 = input.LA(2);

                if ( (synpred73_ASCollector()) ) {
                    alt13=2;
                }
                else if ( (true) ) {
                    alt13=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 13, 5, input);

                    throw nvae;
                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }

            switch (alt13) {
                case 1 :
                    // ASCollector.g3:960:11: xmlAttributeIdentifier
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlAttributeIdentifier_in_xmlPropertyIdentifier5020);
                    xmlAttributeIdentifier20=xmlAttributeIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlAttributeIdentifier20.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:961:11: xmlQualifiedIdentifier
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlQualifiedIdentifier_in_xmlPropertyIdentifier5032);
                    xmlQualifiedIdentifier21=xmlQualifiedIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlQualifiedIdentifier21.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:962:11: s= STAR
                    {
                    root_0 = (Object)adaptor.nil();

                    s=(Token)match(input,STAR,FOLLOW_STAR_in_xmlPropertyIdentifier5046); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    s_tree = (Object)adaptor.create(s);
                    adaptor.addChild(root_0, s_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 16, xmlPropertyIdentifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlPropertyIdentifier"

    public static class xmlAttributeIdentifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlAttributeIdentifier"
    // ASCollector.g3:965:1: xmlAttributeIdentifier : at= XML_AT ( xmlQualifiedIdentifier | xmlPropertySelector | indexSuffix ) ;
    public final ASCollectorParser.xmlAttributeIdentifier_return xmlAttributeIdentifier() throws RecognitionException {
        ASCollectorParser.xmlAttributeIdentifier_return retval = new ASCollectorParser.xmlAttributeIdentifier_return();
        retval.start = input.LT(1);
        int xmlAttributeIdentifier_StartIndex = input.index();
        Object root_0 = null;

        Token at=null;
        ASCollectorParser.xmlQualifiedIdentifier_return xmlQualifiedIdentifier22 = null;

        ASCollectorParser.xmlPropertySelector_return xmlPropertySelector23 = null;

        ASCollectorParser.indexSuffix_return indexSuffix24 = null;


        Object at_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return retval; }
            // ASCollector.g3:966:5: (at= XML_AT ( xmlQualifiedIdentifier | xmlPropertySelector | indexSuffix ) )
            // ASCollector.g3:966:9: at= XML_AT ( xmlQualifiedIdentifier | xmlPropertySelector | indexSuffix )
            {
            root_0 = (Object)adaptor.nil();

            at=(Token)match(input,XML_AT,FOLLOW_XML_AT_in_xmlAttributeIdentifier5110); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            at_tree = (Object)adaptor.create(at);
            adaptor.addChild(root_0, at_tree);
            }
            // ASCollector.g3:967:9: ( xmlQualifiedIdentifier | xmlPropertySelector | indexSuffix )
            int alt14=3;
            switch ( input.LA(1) ) {
            case IDENTIFIER:
                {
                int LA14_1 = input.LA(2);

                if ( (synpred74_ASCollector()) ) {
                    alt14=1;
                }
                else if ( (synpred75_ASCollector()) ) {
                    alt14=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 1, input);

                    throw nvae;
                }
                }
                break;
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NEW:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case INCLUDE:
                {
                int LA14_2 = input.LA(2);

                if ( (synpred74_ASCollector()) ) {
                    alt14=1;
                }
                else if ( (synpred75_ASCollector()) ) {
                    alt14=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 2, input);

                    throw nvae;
                }
                }
                break;
            case NATIVE:
            case TO:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
                {
                int LA14_3 = input.LA(2);

                if ( (synpred74_ASCollector()) ) {
                    alt14=1;
                }
                else if ( (synpred75_ASCollector()) ) {
                    alt14=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 3, input);

                    throw nvae;
                }
                }
                break;
            case STAR:
                {
                int LA14_4 = input.LA(2);

                if ( (synpred74_ASCollector()) ) {
                    alt14=1;
                }
                else if ( (synpred75_ASCollector()) ) {
                    alt14=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 4, input);

                    throw nvae;
                }
                }
                break;
            case LBRACK:
                {
                alt14=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }

            switch (alt14) {
                case 1 :
                    // ASCollector.g3:968:12: xmlQualifiedIdentifier
                    {
                    pushFollow(FOLLOW_xmlQualifiedIdentifier_in_xmlAttributeIdentifier5135);
                    xmlQualifiedIdentifier22=xmlQualifiedIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlQualifiedIdentifier22.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:969:14: xmlPropertySelector
                    {
                    pushFollow(FOLLOW_xmlPropertySelector_in_xmlAttributeIdentifier5150);
                    xmlPropertySelector23=xmlPropertySelector();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPropertySelector23.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:970:14: indexSuffix
                    {
                    pushFollow(FOLLOW_indexSuffix_in_xmlAttributeIdentifier5165);
                    indexSuffix24=indexSuffix();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, indexSuffix24.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 17, xmlAttributeIdentifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlAttributeIdentifier"

    public static class xmlPropertySelector_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlPropertySelector"
    // ASCollector.g3:974:1: xmlPropertySelector : ( xmlNameLiteral | s= STAR );
    public final ASCollectorParser.xmlPropertySelector_return xmlPropertySelector() throws RecognitionException {
        ASCollectorParser.xmlPropertySelector_return retval = new ASCollectorParser.xmlPropertySelector_return();
        retval.start = input.LT(1);
        int xmlPropertySelector_StartIndex = input.index();
        Object root_0 = null;

        Token s=null;
        ASCollectorParser.xmlNameLiteral_return xmlNameLiteral25 = null;


        Object s_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return retval; }
            // ASCollector.g3:975:5: ( xmlNameLiteral | s= STAR )
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( ((LA15_0>=AS && LA15_0<=STATIC)||LA15_0==IDENTIFIER) ) {
                alt15=1;
            }
            else if ( (LA15_0==STAR) ) {
                alt15=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }
            switch (alt15) {
                case 1 :
                    // ASCollector.g3:975:9: xmlNameLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlNameLiteral_in_xmlPropertySelector5255);
                    xmlNameLiteral25=xmlNameLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlNameLiteral25.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:976:9: s= STAR
                    {
                    root_0 = (Object)adaptor.nil();

                    s=(Token)match(input,STAR,FOLLOW_STAR_in_xmlPropertySelector5268); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    s_tree = (Object)adaptor.create(s);
                    adaptor.addChild(root_0, s_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 18, xmlPropertySelector_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlPropertySelector"

    public static class xmlQualifiedIdentifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlQualifiedIdentifier"
    // ASCollector.g3:979:1: xmlQualifiedIdentifier : xmlPropertySelector x= XML_NS_OP ( xmlPropertySelector | indexSuffix ) ;
    public final ASCollectorParser.xmlQualifiedIdentifier_return xmlQualifiedIdentifier() throws RecognitionException {
        ASCollectorParser.xmlQualifiedIdentifier_return retval = new ASCollectorParser.xmlQualifiedIdentifier_return();
        retval.start = input.LT(1);
        int xmlQualifiedIdentifier_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;
        ASCollectorParser.xmlPropertySelector_return xmlPropertySelector26 = null;

        ASCollectorParser.xmlPropertySelector_return xmlPropertySelector27 = null;

        ASCollectorParser.indexSuffix_return indexSuffix28 = null;


        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return retval; }
            // ASCollector.g3:980:5: ( xmlPropertySelector x= XML_NS_OP ( xmlPropertySelector | indexSuffix ) )
            // ASCollector.g3:980:9: xmlPropertySelector x= XML_NS_OP ( xmlPropertySelector | indexSuffix )
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_xmlPropertySelector_in_xmlQualifiedIdentifier5288);
            xmlPropertySelector26=xmlPropertySelector();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPropertySelector26.getTree());
            x=(Token)match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_xmlQualifiedIdentifier5293); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }
            // ASCollector.g3:981:5: ( xmlPropertySelector | indexSuffix )
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( ((LA16_0>=AS && LA16_0<=STATIC)||LA16_0==STAR||LA16_0==IDENTIFIER) ) {
                alt16=1;
            }
            else if ( (LA16_0==LBRACK) ) {
                alt16=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }
            switch (alt16) {
                case 1 :
                    // ASCollector.g3:982:9: xmlPropertySelector
                    {
                    pushFollow(FOLLOW_xmlPropertySelector_in_xmlQualifiedIdentifier5327);
                    xmlPropertySelector27=xmlPropertySelector();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPropertySelector27.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:983:11: indexSuffix
                    {
                    pushFollow(FOLLOW_indexSuffix_in_xmlQualifiedIdentifier5339);
                    indexSuffix28=indexSuffix();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, indexSuffix28.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 19, xmlQualifiedIdentifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlQualifiedIdentifier"

    public static class xmlInitialiser_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlInitialiser"
    // ASCollector.g3:987:1: xmlInitialiser : ( xmlMarkup | xmlElement );
    public final ASCollectorParser.xmlInitialiser_return xmlInitialiser() throws RecognitionException {
        ASCollectorParser.xmlInitialiser_return retval = new ASCollectorParser.xmlInitialiser_return();
        retval.start = input.LT(1);
        int xmlInitialiser_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlMarkup_return xmlMarkup29 = null;

        ASCollectorParser.xmlElement_return xmlElement30 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return retval; }
            // ASCollector.g3:988:5: ( xmlMarkup | xmlElement )
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( ((LA17_0>=XML_COMMENT && LA17_0<=XML_PI)) ) {
                alt17=1;
            }
            else if ( (LA17_0==LT) ) {
                alt17=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }
            switch (alt17) {
                case 1 :
                    // ASCollector.g3:988:9: xmlMarkup
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlMarkup_in_xmlInitialiser5364);
                    xmlMarkup29=xmlMarkup();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlMarkup29.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:989:9: xmlElement
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlElement_in_xmlInitialiser5374);
                    xmlElement30=xmlElement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlElement30.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 20, xmlInitialiser_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlInitialiser"

    public static class xmlElement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlElement"
    // ASCollector.g3:992:1: xmlElement : L= LT xmlTagName ( xmlAttributes )? (x= XML_TEND | G= GT ( xmlElementContent )? x= XML_E_TEND xmlTagName G= GT ) ;
    public final ASCollectorParser.xmlElement_return xmlElement() throws RecognitionException {
        ASCollectorParser.xmlElement_return retval = new ASCollectorParser.xmlElement_return();
        retval.start = input.LT(1);
        int xmlElement_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token x=null;
        Token G=null;
        ASCollectorParser.xmlTagName_return xmlTagName31 = null;

        ASCollectorParser.xmlAttributes_return xmlAttributes32 = null;

        ASCollectorParser.xmlElementContent_return xmlElementContent33 = null;

        ASCollectorParser.xmlTagName_return xmlTagName34 = null;


        Object L_tree=null;
        Object x_tree=null;
        Object G_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return retval; }
            // ASCollector.g3:993:5: (L= LT xmlTagName ( xmlAttributes )? (x= XML_TEND | G= GT ( xmlElementContent )? x= XML_E_TEND xmlTagName G= GT ) )
            // ASCollector.g3:996:5: L= LT xmlTagName ( xmlAttributes )? (x= XML_TEND | G= GT ( xmlElementContent )? x= XML_E_TEND xmlTagName G= GT )
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LT,FOLLOW_LT_in_xmlElement5411); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_xmlTagName_in_xmlElement5414);
            xmlTagName31=xmlTagName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlTagName31.getTree());
            // ASCollector.g3:996:22: ( xmlAttributes )?
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( ((LA18_0>=AS && LA18_0<=STATIC)||LA18_0==LCURLY||LA18_0==IDENTIFIER) ) {
                alt18=1;
            }
            switch (alt18) {
                case 1 :
                    // ASCollector.g3:0:0: xmlAttributes
                    {
                    pushFollow(FOLLOW_xmlAttributes_in_xmlElement5416);
                    xmlAttributes32=xmlAttributes();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlAttributes32.getTree());

                    }
                    break;

            }

            // ASCollector.g3:997:5: (x= XML_TEND | G= GT ( xmlElementContent )? x= XML_E_TEND xmlTagName G= GT )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==XML_TEND) ) {
                alt20=1;
            }
            else if ( (LA20_0==GT) ) {
                alt20=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }
            switch (alt20) {
                case 1 :
                    // ASCollector.g3:998:9: x= XML_TEND
                    {
                    x=(Token)match(input,XML_TEND,FOLLOW_XML_TEND_in_xmlElement5436); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    x_tree = (Object)adaptor.create(x);
                    adaptor.addChild(root_0, x_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1002:9: G= GT ( xmlElementContent )? x= XML_E_TEND xmlTagName G= GT
                    {
                    G=(Token)match(input,GT,FOLLOW_GT_in_xmlElement5478); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    G_tree = (Object)adaptor.create(G);
                    adaptor.addChild(root_0, G_tree);
                    }
                    // ASCollector.g3:1002:14: ( xmlElementContent )?
                    int alt19=2;
                    int LA19_0 = input.LA(1);

                    if ( ((LA19_0>=AS && LA19_0<=LTE)||(LA19_0>=EQ && LA19_0<=SHL)||(LA19_0>=AND && LA19_0<=SHL_ASSIGN)||(LA19_0>=LAND_ASSIGN && LA19_0<=XML_ELLIPSIS)||(LA19_0>=XML_NS_OP && LA19_0<=XML_AT)||(LA19_0>=SINGLE_QUOTE_LITERAL && LA19_0<=DOUBLE_QUOTE_LITERAL)||LA19_0==HEX_NUMBER_LITERAL||LA19_0==DEC_NUMBER_LITERAL||LA19_0==IDENTIFIER||(LA19_0>=XML_COMMENT && LA19_0<=XML_TEXT)) ) {
                        alt19=1;
                    }
                    switch (alt19) {
                        case 1 :
                            // ASCollector.g3:0:0: xmlElementContent
                            {
                            pushFollow(FOLLOW_xmlElementContent_in_xmlElement5480);
                            xmlElementContent33=xmlElementContent();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlElementContent33.getTree());

                            }
                            break;

                    }

                    x=(Token)match(input,XML_E_TEND,FOLLOW_XML_E_TEND_in_xmlElement5494); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    x_tree = (Object)adaptor.create(x);
                    adaptor.addChild(root_0, x_tree);
                    }
                    pushFollow(FOLLOW_xmlTagName_in_xmlElement5506);
                    xmlTagName34=xmlTagName();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlTagName34.getTree());
                    G=(Token)match(input,GT,FOLLOW_GT_in_xmlElement5510); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    G_tree = (Object)adaptor.create(G);
                    adaptor.addChild(root_0, G_tree);
                    }

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 21, xmlElement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlElement"

    public static class xmlAttributes_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlAttributes"
    // ASCollector.g3:1009:1: xmlAttributes : ( xmlAttribute )+ ;
    public final ASCollectorParser.xmlAttributes_return xmlAttributes() throws RecognitionException {
        ASCollectorParser.xmlAttributes_return retval = new ASCollectorParser.xmlAttributes_return();
        retval.start = input.LT(1);
        int xmlAttributes_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlAttribute_return xmlAttribute35 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return retval; }
            // ASCollector.g3:1010:5: ( ( xmlAttribute )+ )
            // ASCollector.g3:1010:9: ( xmlAttribute )+
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1010:9: ( xmlAttribute )+
            int cnt21=0;
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( ((LA21_0>=AS && LA21_0<=STATIC)||LA21_0==LCURLY||LA21_0==IDENTIFIER) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // ASCollector.g3:0:0: xmlAttribute
            	    {
            	    pushFollow(FOLLOW_xmlAttribute_in_xmlAttributes5546);
            	    xmlAttribute35=xmlAttribute();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlAttribute35.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt21 >= 1 ) break loop21;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(21, input);
                        throw eee;
                }
                cnt21++;
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 22, xmlAttributes_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlAttributes"

    public static class xmlTagName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlTagName"
    // ASCollector.g3:1013:1: xmlTagName : ( xmlExprEval | xmlNameLiteral );
    public final ASCollectorParser.xmlTagName_return xmlTagName() throws RecognitionException {
        ASCollectorParser.xmlTagName_return retval = new ASCollectorParser.xmlTagName_return();
        retval.start = input.LT(1);
        int xmlTagName_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlExprEval_return xmlExprEval36 = null;

        ASCollectorParser.xmlNameLiteral_return xmlNameLiteral37 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return retval; }
            // ASCollector.g3:1014:5: ( xmlExprEval | xmlNameLiteral )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==LCURLY) ) {
                alt22=1;
            }
            else if ( ((LA22_0>=AS && LA22_0<=STATIC)||LA22_0==IDENTIFIER) ) {
                alt22=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // ASCollector.g3:1014:9: xmlExprEval
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlExprEval_in_xmlTagName5576);
                    xmlExprEval36=xmlExprEval();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlExprEval36.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1015:9: xmlNameLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlNameLiteral_in_xmlTagName5586);
                    xmlNameLiteral37=xmlNameLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlNameLiteral37.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 23, xmlTagName_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlTagName"

    public static class xmlAttribute_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlAttribute"
    // ASCollector.g3:1018:1: xmlAttribute : {...}? xmlTagName A= ASSIGN ( xmlExprEval | stringLiteral ) ;
    public final ASCollectorParser.xmlAttribute_return xmlAttribute() throws RecognitionException {
        ASCollectorParser.xmlAttribute_return retval = new ASCollectorParser.xmlAttribute_return();
        retval.start = input.LT(1);
        int xmlAttribute_StartIndex = input.index();
        Object root_0 = null;

        Token A=null;
        ASCollectorParser.xmlTagName_return xmlTagName38 = null;

        ASCollectorParser.xmlExprEval_return xmlExprEval39 = null;

        ASCollectorParser.stringLiteral_return stringLiteral40 = null;


        Object A_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return retval; }
            // ASCollector.g3:1019:5: ({...}? xmlTagName A= ASSIGN ( xmlExprEval | stringLiteral ) )
            // ASCollector.g3:1019:8: {...}? xmlTagName A= ASSIGN ( xmlExprEval | stringLiteral )
            {
            root_0 = (Object)adaptor.nil();

            if ( !((promoteWhitespace())) ) {
                if (state.backtracking>0) {state.failed=true; return retval;}
                throw new FailedPredicateException(input, "xmlAttribute", "promoteWhitespace()");
            }
            pushFollow(FOLLOW_xmlTagName_in_xmlAttribute5608);
            xmlTagName38=xmlTagName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlTagName38.getTree());
            A=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_xmlAttribute5613); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            A_tree = (Object)adaptor.create(A);
            adaptor.addChild(root_0, A_tree);
            }
            // ASCollector.g3:1020:5: ( xmlExprEval | stringLiteral )
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==LCURLY) ) {
                alt23=1;
            }
            else if ( ((LA23_0>=SINGLE_QUOTE_LITERAL && LA23_0<=DOUBLE_QUOTE_LITERAL)) ) {
                alt23=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }
            switch (alt23) {
                case 1 :
                    // ASCollector.g3:1021:9: xmlExprEval
                    {
                    pushFollow(FOLLOW_xmlExprEval_in_xmlAttribute5631);
                    xmlExprEval39=xmlExprEval();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlExprEval39.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1022:11: stringLiteral
                    {
                    pushFollow(FOLLOW_stringLiteral_in_xmlAttribute5643);
                    stringLiteral40=stringLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, stringLiteral40.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 24, xmlAttribute_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlAttribute"

    public static class xmlElementContent_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlElementContent"
    // ASCollector.g3:1026:1: xmlElementContent : ( xmlElementContentHelper )+ ;
    public final ASCollectorParser.xmlElementContent_return xmlElementContent() throws RecognitionException {
        ASCollectorParser.xmlElementContent_return retval = new ASCollectorParser.xmlElementContent_return();
        retval.start = input.LT(1);
        int xmlElementContent_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlElementContentHelper_return xmlElementContentHelper41 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return retval; }
            // ASCollector.g3:1027:5: ( ( xmlElementContentHelper )+ )
            // ASCollector.g3:1027:8: ( xmlElementContentHelper )+
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1027:8: ( xmlElementContentHelper )+
            int cnt24=0;
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( ((LA24_0>=AS && LA24_0<=LTE)||(LA24_0>=EQ && LA24_0<=SHL)||(LA24_0>=AND && LA24_0<=SHL_ASSIGN)||(LA24_0>=LAND_ASSIGN && LA24_0<=XML_ELLIPSIS)||(LA24_0>=XML_NS_OP && LA24_0<=XML_AT)||(LA24_0>=SINGLE_QUOTE_LITERAL && LA24_0<=DOUBLE_QUOTE_LITERAL)||LA24_0==HEX_NUMBER_LITERAL||LA24_0==DEC_NUMBER_LITERAL||LA24_0==IDENTIFIER||(LA24_0>=XML_COMMENT && LA24_0<=XML_TEXT)) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // ASCollector.g3:0:0: xmlElementContentHelper
            	    {
            	    pushFollow(FOLLOW_xmlElementContentHelper_in_xmlElementContent5674);
            	    xmlElementContentHelper41=xmlElementContentHelper();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlElementContentHelper41.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt24 >= 1 ) break loop24;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(24, input);
                        throw eee;
                }
                cnt24++;
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 25, xmlElementContent_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlElementContent"

    public static class xmlElementContentHelper_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlElementContentHelper"
    // ASCollector.g3:1030:1: xmlElementContentHelper : ( xmlExprEval | xmlMarkup | xmlElement | xmlText );
    public final ASCollectorParser.xmlElementContentHelper_return xmlElementContentHelper() throws RecognitionException {
        ASCollectorParser.xmlElementContentHelper_return retval = new ASCollectorParser.xmlElementContentHelper_return();
        retval.start = input.LT(1);
        int xmlElementContentHelper_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.xmlExprEval_return xmlExprEval42 = null;

        ASCollectorParser.xmlMarkup_return xmlMarkup43 = null;

        ASCollectorParser.xmlElement_return xmlElement44 = null;

        ASCollectorParser.xmlText_return xmlText45 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return retval; }
            // ASCollector.g3:1031:5: ( xmlExprEval | xmlMarkup | xmlElement | xmlText )
            int alt25=4;
            switch ( input.LA(1) ) {
            case LCURLY:
                {
                alt25=1;
                }
                break;
            case XML_COMMENT:
            case XML_CDATA:
            case XML_PI:
                {
                alt25=2;
                }
                break;
            case LT:
                {
                alt25=3;
                }
                break;
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NATIVE:
            case NEW:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TO:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case INCLUDE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case SEMI:
            case RCURLY:
            case LPAREN:
            case RPAREN:
            case LBRACK:
            case RBRACK:
            case DOT:
            case COMMA:
            case GT:
            case LTE:
            case EQ:
            case NEQ:
            case SAME:
            case NSAME:
            case PLUS:
            case SUB:
            case STAR:
            case DIV:
            case MOD:
            case INC:
            case DEC:
            case SHL:
            case AND:
            case OR:
            case XOR:
            case NOT:
            case INV:
            case LAND:
            case LOR:
            case QUE:
            case COLON:
            case ASSIGN:
            case DIV_ASSIGN:
            case MOD_ASSIGN:
            case ADD_ASSIGN:
            case SUB_ASSIGN:
            case SHL_ASSIGN:
            case LAND_ASSIGN:
            case LOR_ASSIGN:
            case AND_ASSIGN:
            case XOR_ASSIGN:
            case OR_ASSIGN:
            case ELLIPSIS:
            case XML_ELLIPSIS:
            case XML_NS_OP:
            case XML_AT:
            case SINGLE_QUOTE_LITERAL:
            case DOUBLE_QUOTE_LITERAL:
            case HEX_NUMBER_LITERAL:
            case DEC_NUMBER_LITERAL:
            case IDENTIFIER:
            case XML_TEXT:
                {
                alt25=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }

            switch (alt25) {
                case 1 :
                    // ASCollector.g3:1031:7: xmlExprEval
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlExprEval_in_xmlElementContentHelper5692);
                    xmlExprEval42=xmlExprEval();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlExprEval42.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1032:7: xmlMarkup
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlMarkup_in_xmlElementContentHelper5701);
                    xmlMarkup43=xmlMarkup();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlMarkup43.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1033:7: xmlElement
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlElement_in_xmlElementContentHelper5710);
                    xmlElement44=xmlElement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlElement44.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:1034:7: xmlText
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlText_in_xmlElementContentHelper5719);
                    xmlText45=xmlText();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlText45.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 26, xmlElementContentHelper_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlElementContentHelper"

    public static class xmlListInitialiser_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlListInitialiser"
    // ASCollector.g3:1038:1: xmlListInitialiser : x= XML_LS_STD ( xmlElementContent )? x= XML_LS_END ;
    public final ASCollectorParser.xmlListInitialiser_return xmlListInitialiser() throws RecognitionException {
        ASCollectorParser.xmlListInitialiser_return retval = new ASCollectorParser.xmlListInitialiser_return();
        retval.start = input.LT(1);
        int xmlListInitialiser_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;
        ASCollectorParser.xmlElementContent_return xmlElementContent46 = null;


        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return retval; }
            // ASCollector.g3:1039:5: (x= XML_LS_STD ( xmlElementContent )? x= XML_LS_END )
            // ASCollector.g3:1039:10: x= XML_LS_STD ( xmlElementContent )? x= XML_LS_END
            {
            root_0 = (Object)adaptor.nil();

            x=(Token)match(input,XML_LS_STD,FOLLOW_XML_LS_STD_in_xmlListInitialiser5739); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }
            // ASCollector.g3:1041:5: ( xmlElementContent )?
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( ((LA26_0>=AS && LA26_0<=LTE)||(LA26_0>=EQ && LA26_0<=SHL)||(LA26_0>=AND && LA26_0<=SHL_ASSIGN)||(LA26_0>=LAND_ASSIGN && LA26_0<=XML_ELLIPSIS)||(LA26_0>=XML_NS_OP && LA26_0<=XML_AT)||(LA26_0>=SINGLE_QUOTE_LITERAL && LA26_0<=DOUBLE_QUOTE_LITERAL)||LA26_0==HEX_NUMBER_LITERAL||LA26_0==DEC_NUMBER_LITERAL||LA26_0==IDENTIFIER||(LA26_0>=XML_COMMENT && LA26_0<=XML_TEXT)) ) {
                alt26=1;
            }
            switch (alt26) {
                case 1 :
                    // ASCollector.g3:0:0: xmlElementContent
                    {
                    pushFollow(FOLLOW_xmlElementContent_in_xmlListInitialiser5751);
                    xmlElementContent46=xmlElementContent();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlElementContent46.getTree());

                    }
                    break;

            }

            x=(Token)match(input,XML_LS_END,FOLLOW_XML_LS_END_in_xmlListInitialiser5762); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 27, xmlListInitialiser_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlListInitialiser"

    public static class semic_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "semic"
    // ASCollector.g3:1046:1: semic : (S= SEMI | E= EOF | R= RCURLY );
    public final ASCollectorParser.semic_return semic() throws RecognitionException {
        ASCollectorParser.semic_return retval = new ASCollectorParser.semic_return();
        retval.start = input.LT(1);
        int semic_StartIndex = input.index();
        Object root_0 = null;

        Token S=null;
        Token E=null;
        Token R=null;

        Object S_tree=null;
        Object E_tree=null;
        Object R_tree=null;


            // Mark current position so we can unconsume a RBRACE.
            int marker = input.mark();
            // Promote EOL if appropriate
            boolean onBrace=false;
            if (retval.start.getText()!=null && retval.start.getText().equals("}"))
            {
            	onBrace=true;
        		if (state.backtracking>0)
        		{
        			retval.stop=retval.start;
        		    return retval; //we don't want to consume the '}' during the prediction phase
        		}    	
            }
            	
            if (findVirtualHiddenToken(retval))
            {
               retval.stop=retval.start;
               return retval;
            }

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return retval; }
            // ASCollector.g3:1069:5: (S= SEMI | E= EOF | R= RCURLY )
            int alt27=3;
            switch ( input.LA(1) ) {
            case SEMI:
                {
                alt27=1;
                }
                break;
            case EOF:
                {
                alt27=2;
                }
                break;
            case RCURLY:
                {
                alt27=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 27, 0, input);

                throw nvae;
            }

            switch (alt27) {
                case 1 :
                    // ASCollector.g3:1069:9: S= SEMI
                    {
                    root_0 = (Object)adaptor.nil();

                    S=(Token)match(input,SEMI,FOLLOW_SEMI_in_semic5797); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1070:9: E= EOF
                    {
                    root_0 = (Object)adaptor.nil();

                    E=(Token)match(input,EOF,FOLLOW_EOF_in_semic5810); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    E_tree = (Object)adaptor.create(E);
                    adaptor.addChild(root_0, E_tree);
                    }

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1071:9: R= RCURLY
                    {
                    root_0 = (Object)adaptor.nil();

                    R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_semic5823); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    R_tree = (Object)adaptor.create(R);
                    adaptor.addChild(root_0, R_tree);
                    }
                    if ( state.backtracking==0 ) {
                       input.rewind(marker); 
                                          if (onBrace)
                                          {
                                               retval.start=input.LT(-1);
                                               retval.stop=retval.start;
                                               retval.tree=null;
                                               return retval;
                                          }
                                       
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 28, semic_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "semic"

    public static class fileContents_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "fileContents"
    // ASCollector.g3:1085:1: fileContents : ( ( ( packageDeclaration )? ( packageElement )* ) | EOF );
    public final ASCollectorParser.fileContents_return fileContents() throws RecognitionException {
        ASCollectorParser.fileContents_return retval = new ASCollectorParser.fileContents_return();
        retval.start = input.LT(1);
        int fileContents_StartIndex = input.index();
        Object root_0 = null;

        Token EOF49=null;
        ASCollectorParser.packageDeclaration_return packageDeclaration47 = null;

        ASCollectorParser.packageElement_return packageElement48 = null;


        Object EOF49_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return retval; }
            // ASCollector.g3:1086:2: ( ( ( packageDeclaration )? ( packageElement )* ) | EOF )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( ((LA30_0>=AS && LA30_0<=LCURLY)||LA30_0==LPAREN||LA30_0==LBRACK||LA30_0==LT||(LA30_0>=PLUS && LA30_0<=STAR)||(LA30_0>=INC && LA30_0<=DEC)||(LA30_0>=NOT && LA30_0<=INV)||(LA30_0>=XML_AT && LA30_0<=XML_LS_STD)||(LA30_0>=SINGLE_QUOTE_LITERAL && LA30_0<=DOUBLE_QUOTE_LITERAL)||LA30_0==REGULAR_EXPR_LITERAL||LA30_0==HEX_NUMBER_LITERAL||LA30_0==DEC_NUMBER_LITERAL||LA30_0==IDENTIFIER||(LA30_0>=XML_COMMENT && LA30_0<=XML_PI)) ) {
                alt30=1;
            }
            else if ( (LA30_0==EOF) ) {
                int LA30_2 = input.LA(2);

                if ( (LA30_2==EOF) ) {
                    alt30=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 30, 2, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // ASCollector.g3:1086:4: ( ( packageDeclaration )? ( packageElement )* )
                    {
                    root_0 = (Object)adaptor.nil();

                    // ASCollector.g3:1086:4: ( ( packageDeclaration )? ( packageElement )* )
                    // ASCollector.g3:1086:5: ( packageDeclaration )? ( packageElement )*
                    {
                    // ASCollector.g3:1086:5: ( packageDeclaration )?
                    int alt28=2;
                    int LA28_0 = input.LA(1);

                    if ( (LA28_0==PACKAGE) ) {
                        int LA28_1 = input.LA(2);

                        if ( (LA28_1==DEFAULT||LA28_1==INTERNAL||LA28_1==NATIVE||LA28_1==TO||LA28_1==VOID||(LA28_1>=EACH && LA28_1<=NAMESPACE)||(LA28_1>=DYNAMIC && LA28_1<=STATIC)||LA28_1==LCURLY||LA28_1==STAR||LA28_1==IDENTIFIER) ) {
                            alt28=1;
                        }
                    }
                    switch (alt28) {
                        case 1 :
                            // ASCollector.g3:0:0: packageDeclaration
                            {
                            pushFollow(FOLLOW_packageDeclaration_in_fileContents5843);
                            packageDeclaration47=packageDeclaration();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, packageDeclaration47.getTree());

                            }
                            break;

                    }

                    // ASCollector.g3:1086:25: ( packageElement )*
                    loop29:
                    do {
                        int alt29=2;
                        int LA29_0 = input.LA(1);

                        if ( ((LA29_0>=AS && LA29_0<=LCURLY)||LA29_0==LPAREN||LA29_0==LBRACK||LA29_0==LT||(LA29_0>=PLUS && LA29_0<=STAR)||(LA29_0>=INC && LA29_0<=DEC)||(LA29_0>=NOT && LA29_0<=INV)||(LA29_0>=XML_AT && LA29_0<=XML_LS_STD)||(LA29_0>=SINGLE_QUOTE_LITERAL && LA29_0<=DOUBLE_QUOTE_LITERAL)||LA29_0==REGULAR_EXPR_LITERAL||LA29_0==HEX_NUMBER_LITERAL||LA29_0==DEC_NUMBER_LITERAL||LA29_0==IDENTIFIER||(LA29_0>=XML_COMMENT && LA29_0<=XML_PI)) ) {
                            alt29=1;
                        }


                        switch (alt29) {
                    	case 1 :
                    	    // ASCollector.g3:0:0: packageElement
                    	    {
                    	    pushFollow(FOLLOW_packageElement_in_fileContents5846);
                    	    packageElement48=packageElement();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, packageElement48.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop29;
                        }
                    } while (true);


                    }


                    }
                    break;
                case 2 :
                    // ASCollector.g3:1086:44: EOF
                    {
                    root_0 = (Object)adaptor.nil();

                    EOF49=(Token)match(input,EOF,FOLLOW_EOF_in_fileContents5852); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    EOF49_tree = (Object)adaptor.create(EOF49);
                    adaptor.addChild(root_0, EOF49_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 29, fileContents_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "fileContents"

    public static class packageDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "packageDeclaration"
    // ASCollector.g3:1091:1: packageDeclaration : p= PACKAGE ( type )? l= LCURLY ( packageElement )* r= RCURLY ;
    public final ASCollectorParser.packageDeclaration_return packageDeclaration() throws RecognitionException {
        ASCollectorParser.packageDeclaration_return retval = new ASCollectorParser.packageDeclaration_return();
        retval.start = input.LT(1);
        int packageDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token p=null;
        Token l=null;
        Token r=null;
        ASCollectorParser.type_return type50 = null;

        ASCollectorParser.packageElement_return packageElement51 = null;


        Object p_tree=null;
        Object l_tree=null;
        Object r_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return retval; }
            // ASCollector.g3:1092:2: (p= PACKAGE ( type )? l= LCURLY ( packageElement )* r= RCURLY )
            // ASCollector.g3:1092:6: p= PACKAGE ( type )? l= LCURLY ( packageElement )* r= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            p=(Token)match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration5869); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            p_tree = (Object)adaptor.create(p);
            adaptor.addChild(root_0, p_tree);
            }
            // ASCollector.g3:1092:16: ( type )?
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0==DEFAULT||LA31_0==INTERNAL||LA31_0==NATIVE||LA31_0==TO||LA31_0==VOID||(LA31_0>=EACH && LA31_0<=NAMESPACE)||(LA31_0>=DYNAMIC && LA31_0<=STATIC)||LA31_0==STAR||LA31_0==IDENTIFIER) ) {
                alt31=1;
            }
            switch (alt31) {
                case 1 :
                    // ASCollector.g3:1092:17: type
                    {
                    pushFollow(FOLLOW_type_in_packageDeclaration5872);
                    type50=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type50.getTree());

                    }
                    break;

            }

            l=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_packageDeclaration5885); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            l_tree = (Object)adaptor.create(l);
            adaptor.addChild(root_0, l_tree);
            }
            if ( state.backtracking==0 ) {
              addCollector();getCollector().setPackageOpen(l);
            }
            // ASCollector.g3:1095:6: ( packageElement )*
            loop32:
            do {
                int alt32=2;
                int LA32_0 = input.LA(1);

                if ( ((LA32_0>=AS && LA32_0<=LCURLY)||LA32_0==LPAREN||LA32_0==LBRACK||LA32_0==LT||(LA32_0>=PLUS && LA32_0<=STAR)||(LA32_0>=INC && LA32_0<=DEC)||(LA32_0>=NOT && LA32_0<=INV)||(LA32_0>=XML_AT && LA32_0<=XML_LS_STD)||(LA32_0>=SINGLE_QUOTE_LITERAL && LA32_0<=DOUBLE_QUOTE_LITERAL)||LA32_0==REGULAR_EXPR_LITERAL||LA32_0==HEX_NUMBER_LITERAL||LA32_0==DEC_NUMBER_LITERAL||LA32_0==IDENTIFIER||(LA32_0>=XML_COMMENT && LA32_0<=XML_PI)) ) {
                    alt32=1;
                }


                switch (alt32) {
            	case 1 :
            	    // ASCollector.g3:0:0: packageElement
            	    {
            	    pushFollow(FOLLOW_packageElement_in_packageDeclaration5901);
            	    packageElement51=packageElement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, packageElement51.getTree());

            	    }
            	    break;

            	default :
            	    break loop32;
                }
            } while (true);

            r=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_packageDeclaration5913); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            r_tree = (Object)adaptor.create(r);
            adaptor.addChild(root_0, r_tree);
            }
            if ( state.backtracking==0 ) {
              getCollector().setPackageClose(r);addCollector();
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 30, packageDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "packageDeclaration"

    public static class mxmlEmbedded_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "mxmlEmbedded"
    // ASCollector.g3:1103:1: mxmlEmbedded : ( conditionalCompilerOption LCURLY mxmlEmbedded RCURLY | propertyDeclaration | functionDeclaration[true] | statement | directive | interfaceFunctionDeclaration[true] )* ( EOF )? ;
    public final ASCollectorParser.mxmlEmbedded_return mxmlEmbedded() throws RecognitionException {
        ASCollectorParser.mxmlEmbedded_return retval = new ASCollectorParser.mxmlEmbedded_return();
        retval.start = input.LT(1);
        int mxmlEmbedded_StartIndex = input.index();
        Object root_0 = null;

        Token LCURLY53=null;
        Token RCURLY55=null;
        Token EOF61=null;
        ASCollectorParser.conditionalCompilerOption_return conditionalCompilerOption52 = null;

        ASCollectorParser.mxmlEmbedded_return mxmlEmbedded54 = null;

        ASCollectorParser.propertyDeclaration_return propertyDeclaration56 = null;

        ASCollectorParser.functionDeclaration_return functionDeclaration57 = null;

        ASCollectorParser.statement_return statement58 = null;

        ASCollectorParser.directive_return directive59 = null;

        ASCollectorParser.interfaceFunctionDeclaration_return interfaceFunctionDeclaration60 = null;


        Object LCURLY53_tree=null;
        Object RCURLY55_tree=null;
        Object EOF61_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return retval; }
            // ASCollector.g3:1104:2: ( ( conditionalCompilerOption LCURLY mxmlEmbedded RCURLY | propertyDeclaration | functionDeclaration[true] | statement | directive | interfaceFunctionDeclaration[true] )* ( EOF )? )
            // ASCollector.g3:1105:3: ( conditionalCompilerOption LCURLY mxmlEmbedded RCURLY | propertyDeclaration | functionDeclaration[true] | statement | directive | interfaceFunctionDeclaration[true] )* ( EOF )?
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1105:3: ( conditionalCompilerOption LCURLY mxmlEmbedded RCURLY | propertyDeclaration | functionDeclaration[true] | statement | directive | interfaceFunctionDeclaration[true] )*
            loop33:
            do {
                int alt33=7;
                alt33 = dfa33.predict(input);
                switch (alt33) {
            	case 1 :
            	    // ASCollector.g3:1105:4: conditionalCompilerOption LCURLY mxmlEmbedded RCURLY
            	    {
            	    pushFollow(FOLLOW_conditionalCompilerOption_in_mxmlEmbedded5936);
            	    conditionalCompilerOption52=conditionalCompilerOption();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalCompilerOption52.getTree());
            	    LCURLY53=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_mxmlEmbedded5938); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    LCURLY53_tree = (Object)adaptor.create(LCURLY53);
            	    adaptor.addChild(root_0, LCURLY53_tree);
            	    }
            	    pushFollow(FOLLOW_mxmlEmbedded_in_mxmlEmbedded5940);
            	    mxmlEmbedded54=mxmlEmbedded();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, mxmlEmbedded54.getTree());
            	    RCURLY55=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_mxmlEmbedded5942); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    RCURLY55_tree = (Object)adaptor.create(RCURLY55);
            	    adaptor.addChild(root_0, RCURLY55_tree);
            	    }
            	    if ( state.backtracking==0 ) {
            	      mSeenConditionalMemberBlock=true;
            	    }

            	    }
            	    break;
            	case 2 :
            	    // ASCollector.g3:1106:9: propertyDeclaration
            	    {
            	    pushFollow(FOLLOW_propertyDeclaration_in_mxmlEmbedded5955);
            	    propertyDeclaration56=propertyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyDeclaration56.getTree());

            	    }
            	    break;
            	case 3 :
            	    // ASCollector.g3:1106:31: functionDeclaration[true]
            	    {
            	    pushFollow(FOLLOW_functionDeclaration_in_mxmlEmbedded5959);
            	    functionDeclaration57=functionDeclaration(true);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, functionDeclaration57.getTree());

            	    }
            	    break;
            	case 4 :
            	    // ASCollector.g3:1106:59: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_mxmlEmbedded5964);
            	    statement58=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement58.getTree());

            	    }
            	    break;
            	case 5 :
            	    // ASCollector.g3:1106:71: directive
            	    {
            	    pushFollow(FOLLOW_directive_in_mxmlEmbedded5968);
            	    directive59=directive();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, directive59.getTree());

            	    }
            	    break;
            	case 6 :
            	    // ASCollector.g3:1106:83: interfaceFunctionDeclaration[true]
            	    {
            	    pushFollow(FOLLOW_interfaceFunctionDeclaration_in_mxmlEmbedded5972);
            	    interfaceFunctionDeclaration60=interfaceFunctionDeclaration(true);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceFunctionDeclaration60.getTree());

            	    }
            	    break;

            	default :
            	    break loop33;
                }
            } while (true);

            // ASCollector.g3:1107:6: ( EOF )?
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==EOF) ) {
                alt34=1;
            }
            switch (alt34) {
                case 1 :
                    // ASCollector.g3:0:0: EOF
                    {
                    EOF61=(Token)match(input,EOF,FOLLOW_EOF_in_mxmlEmbedded5983); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    EOF61_tree = (Object)adaptor.create(EOF61);
                    adaptor.addChild(root_0, EOF61_tree);
                    }

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 31, mxmlEmbedded_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "mxmlEmbedded"

    public static class packageElement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "packageElement"
    // ASCollector.g3:1110:1: packageElement : ( conditionalCompilerOption LCURLY ( packageElement )* RCURLY | classOrInterfaceDecl | propertyDeclaration | functionDeclaration[true] | interfaceFunctionDeclaration[true] | directive | statement );
    public final ASCollectorParser.packageElement_return packageElement() throws RecognitionException {
        ASCollectorParser.packageElement_return retval = new ASCollectorParser.packageElement_return();
        retval.start = input.LT(1);
        int packageElement_StartIndex = input.index();
        Object root_0 = null;

        Token LCURLY63=null;
        Token RCURLY65=null;
        ASCollectorParser.conditionalCompilerOption_return conditionalCompilerOption62 = null;

        ASCollectorParser.packageElement_return packageElement64 = null;

        ASCollectorParser.classOrInterfaceDecl_return classOrInterfaceDecl66 = null;

        ASCollectorParser.propertyDeclaration_return propertyDeclaration67 = null;

        ASCollectorParser.functionDeclaration_return functionDeclaration68 = null;

        ASCollectorParser.interfaceFunctionDeclaration_return interfaceFunctionDeclaration69 = null;

        ASCollectorParser.directive_return directive70 = null;

        ASCollectorParser.statement_return statement71 = null;


        Object LCURLY63_tree=null;
        Object RCURLY65_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return retval; }
            // ASCollector.g3:1111:5: ( conditionalCompilerOption LCURLY ( packageElement )* RCURLY | classOrInterfaceDecl | propertyDeclaration | functionDeclaration[true] | interfaceFunctionDeclaration[true] | directive | statement )
            int alt36=7;
            alt36 = dfa36.predict(input);
            switch (alt36) {
                case 1 :
                    // ASCollector.g3:1112:4: conditionalCompilerOption LCURLY ( packageElement )* RCURLY
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_conditionalCompilerOption_in_packageElement6005);
                    conditionalCompilerOption62=conditionalCompilerOption();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalCompilerOption62.getTree());
                    LCURLY63=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_packageElement6007); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    LCURLY63_tree = (Object)adaptor.create(LCURLY63);
                    adaptor.addChild(root_0, LCURLY63_tree);
                    }
                    // ASCollector.g3:1112:37: ( packageElement )*
                    loop35:
                    do {
                        int alt35=2;
                        int LA35_0 = input.LA(1);

                        if ( ((LA35_0>=AS && LA35_0<=LCURLY)||LA35_0==LPAREN||LA35_0==LBRACK||LA35_0==LT||(LA35_0>=PLUS && LA35_0<=STAR)||(LA35_0>=INC && LA35_0<=DEC)||(LA35_0>=NOT && LA35_0<=INV)||(LA35_0>=XML_AT && LA35_0<=XML_LS_STD)||(LA35_0>=SINGLE_QUOTE_LITERAL && LA35_0<=DOUBLE_QUOTE_LITERAL)||LA35_0==REGULAR_EXPR_LITERAL||LA35_0==HEX_NUMBER_LITERAL||LA35_0==DEC_NUMBER_LITERAL||LA35_0==IDENTIFIER||(LA35_0>=XML_COMMENT && LA35_0<=XML_PI)) ) {
                            alt35=1;
                        }


                        switch (alt35) {
                    	case 1 :
                    	    // ASCollector.g3:0:0: packageElement
                    	    {
                    	    pushFollow(FOLLOW_packageElement_in_packageElement6009);
                    	    packageElement64=packageElement();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, packageElement64.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop35;
                        }
                    } while (true);

                    RCURLY65=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_packageElement6012); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    RCURLY65_tree = (Object)adaptor.create(RCURLY65);
                    adaptor.addChild(root_0, RCURLY65_tree);
                    }
                    if ( state.backtracking==0 ) {
                      mSeenConditionalMemberBlock=true;
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1113:9: classOrInterfaceDecl
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_classOrInterfaceDecl_in_packageElement6029);
                    classOrInterfaceDecl66=classOrInterfaceDecl();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classOrInterfaceDecl66.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1113:32: propertyDeclaration
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_propertyDeclaration_in_packageElement6033);
                    propertyDeclaration67=propertyDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyDeclaration67.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:1113:54: functionDeclaration[true]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_functionDeclaration_in_packageElement6037);
                    functionDeclaration68=functionDeclaration(true);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, functionDeclaration68.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:1113:82: interfaceFunctionDeclaration[true]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_interfaceFunctionDeclaration_in_packageElement6042);
                    interfaceFunctionDeclaration69=interfaceFunctionDeclaration(true);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceFunctionDeclaration69.getTree());

                    }
                    break;
                case 6 :
                    // ASCollector.g3:1113:119: directive
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_directive_in_packageElement6047);
                    directive70=directive();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, directive70.getTree());

                    }
                    break;
                case 7 :
                    // ASCollector.g3:1113:131: statement
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_statement_in_packageElement6051);
                    statement71=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement71.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 32, packageElement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "packageElement"

    public static class importDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "importDeclaration"
    // ASCollector.g3:1116:1: importDeclaration : i= IMPORT t= type (D= DOT S= STAR )? s= semic ;
    public final ASCollectorParser.importDeclaration_return importDeclaration() throws RecognitionException {
        ASCollectorParser.importDeclaration_return retval = new ASCollectorParser.importDeclaration_return();
        retval.start = input.LT(1);
        int importDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token i=null;
        Token D=null;
        Token S=null;
        ASCollectorParser.type_return t = null;

        ASCollectorParser.semic_return s = null;


        Object i_tree=null;
        Object D_tree=null;
        Object S_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return retval; }
            // ASCollector.g3:1117:2: (i= IMPORT t= type (D= DOT S= STAR )? s= semic )
            // ASCollector.g3:1117:7: i= IMPORT t= type (D= DOT S= STAR )? s= semic
            {
            root_0 = (Object)adaptor.nil();

            i=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration6070); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            i_tree = (Object)adaptor.create(i);
            adaptor.addChild(root_0, i_tree);
            }
            pushFollow(FOLLOW_type_in_importDeclaration6075);
            t=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree());
            // ASCollector.g3:1117:24: (D= DOT S= STAR )?
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( (LA37_0==DOT) ) {
                alt37=1;
            }
            switch (alt37) {
                case 1 :
                    // ASCollector.g3:1117:25: D= DOT S= STAR
                    {
                    D=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration6080); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }
                    S=(Token)match(input,STAR,FOLLOW_STAR_in_importDeclaration6085); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_importDeclaration6092);
            s=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());
            if ( state.backtracking==0 ) {

              			ImportRecord iRec=new ImportRecord();
              			iRec.captureStartPos(i);
              			if (s!=null)
              			{
              				iRec.captureEndPos(s);
              				capturePostHiddenTokens(iRec, s);
              			}
              			else if (S!=null)
              			{
              				iRec.captureEndPos(S);
              				capturePostHiddenTokens(iRec, S);
              			}
              			else
              			{
              				iRec.captureEndPos(t);
              				capturePostHiddenTokens(iRec, t);
              			}
              			iRec.setType(t, S!=null);
              			captureHiddenTokens(iRec, i);
              			if (getClassRecord()==null)
              				getCollector().addImport(iRec);
              			else
              				getClassRecord().addImport(iRec);
              		
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 33, importDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "importDeclaration"

    public static class classOrInterfaceDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classOrInterfaceDecl"
    // ASCollector.g3:1145:1: classOrInterfaceDecl : (cond= conditionalDirAndBindingDecls )? (m= memberModifiers[getClassRecord()] )? (i= interfaceDeclaration | c= classDeclaration ) ;
    public final ASCollectorParser.classOrInterfaceDecl_return classOrInterfaceDecl() throws RecognitionException {
        ASCollectorParser.classOrInterfaceDecl_return retval = new ASCollectorParser.classOrInterfaceDecl_return();
        retval.start = input.LT(1);
        int classOrInterfaceDecl_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.conditionalDirAndBindingDecls_return cond = null;

        ASCollectorParser.memberModifiers_return m = null;

        ASCollectorParser.interfaceDeclaration_return i = null;

        ASCollectorParser.classDeclaration_return c = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return retval; }
            // ASCollector.g3:1146:2: ( (cond= conditionalDirAndBindingDecls )? (m= memberModifiers[getClassRecord()] )? (i= interfaceDeclaration | c= classDeclaration ) )
            // ASCollector.g3:1147:3: (cond= conditionalDirAndBindingDecls )? (m= memberModifiers[getClassRecord()] )? (i= interfaceDeclaration | c= classDeclaration )
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              createClassRecord();
            }
            // ASCollector.g3:1148:3: (cond= conditionalDirAndBindingDecls )?
            int alt38=2;
            switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA38_1 = input.LA(2);

                    if ( (LA38_1==XML_NS_OP) ) {
                        alt38=1;
                    }
                    }
                    break;
                case NATIVE:
                case DYNAMIC:
                case FINAL:
                case OVERRIDE:
                case STATIC:
                    {
                    int LA38_2 = input.LA(2);

                    if ( (LA38_2==XML_NS_OP) ) {
                        alt38=1;
                    }
                    }
                    break;
                case TO:
                case EACH:
                case GET:
                case SET:
                case NAMESPACE:
                    {
                    alt38=1;
                    }
                    break;
            }

            switch (alt38) {
                case 1 :
                    // ASCollector.g3:1148:4: cond= conditionalDirAndBindingDecls
                    {
                    pushFollow(FOLLOW_conditionalDirAndBindingDecls_in_classOrInterfaceDecl6120);
                    cond=conditionalDirAndBindingDecls();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, cond.getTree());
                    if ( state.backtracking==0 ) {
                      getClassRecord().captureStartPos(cond);
                    }

                    }
                    break;

            }

            // ASCollector.g3:1151:3: (m= memberModifiers[getClassRecord()] )?
            int alt39=2;
            int LA39_0 = input.LA(1);

            if ( (LA39_0==INTERNAL||LA39_0==NATIVE||(LA39_0>=PRIVATE && LA39_0<=PUBLIC)||(LA39_0>=DYNAMIC && LA39_0<=STATIC)||LA39_0==IDENTIFIER) ) {
                alt39=1;
            }
            switch (alt39) {
                case 1 :
                    // ASCollector.g3:1151:4: m= memberModifiers[getClassRecord()]
                    {
                    pushFollow(FOLLOW_memberModifiers_in_classOrInterfaceDecl6139);
                    m=memberModifiers(getClassRecord());

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, m.getTree());
                    if ( state.backtracking==0 ) {
                      getClassRecord().captureStartPos(m);
                    }
                    if ( state.backtracking==0 ) {
                      captureHiddenTokens(getClassRecord(), m);
                    }

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
              flushMetatags(getClassRecord());
            }
            // ASCollector.g3:1156:3: (i= interfaceDeclaration | c= classDeclaration )
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( (LA40_0==INTERFACE) ) {
                alt40=1;
            }
            else if ( (LA40_0==CLASS) ) {
                alt40=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 40, 0, input);

                throw nvae;
            }
            switch (alt40) {
                case 1 :
                    // ASCollector.g3:1156:4: i= interfaceDeclaration
                    {
                    pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDecl6167);
                    i=interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, i.getTree());
                    if ( state.backtracking==0 ) {
                      getClassRecord().captureEndPos(i);getClassRecord().setIsClass(false);{if (m==null) captureHiddenTokens(getClassRecord(), i);} capturePostHiddenTokens(getClassRecord(), i);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1157:6: c= classDeclaration
                    {
                    pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDecl6178);
                    c=classDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, c.getTree());
                    if ( state.backtracking==0 ) {
                      getClassRecord().captureEndPos(c); {if (m==null) captureHiddenTokens(getClassRecord(), c);} capturePostHiddenTokens(getClassRecord(), c); 
                    }

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
              closeClassRecord();
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 34, classOrInterfaceDecl_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "classOrInterfaceDecl"

    public static class directive_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "directive"
    // ASCollector.g3:1163:1: directive : ( bindingDecl | includeDirective | useNamespaceDirective | i= importDeclaration | defaultXMLNamespaceDirective ) ;
    public final ASCollectorParser.directive_return directive() throws RecognitionException {
        ASCollectorParser.directive_return retval = new ASCollectorParser.directive_return();
        retval.start = input.LT(1);
        int directive_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.importDeclaration_return i = null;

        ASCollectorParser.bindingDecl_return bindingDecl72 = null;

        ASCollectorParser.includeDirective_return includeDirective73 = null;

        ASCollectorParser.useNamespaceDirective_return useNamespaceDirective74 = null;

        ASCollectorParser.defaultXMLNamespaceDirective_return defaultXMLNamespaceDirective75 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return retval; }
            // ASCollector.g3:1164:2: ( ( bindingDecl | includeDirective | useNamespaceDirective | i= importDeclaration | defaultXMLNamespaceDirective ) )
            // ASCollector.g3:1164:4: ( bindingDecl | includeDirective | useNamespaceDirective | i= importDeclaration | defaultXMLNamespaceDirective )
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1164:4: ( bindingDecl | includeDirective | useNamespaceDirective | i= importDeclaration | defaultXMLNamespaceDirective )
            int alt41=5;
            switch ( input.LA(1) ) {
            case LBRACK:
                {
                alt41=1;
                }
                break;
            case INCLUDE:
                {
                alt41=2;
                }
                break;
            case USE:
                {
                alt41=3;
                }
                break;
            case IMPORT:
                {
                alt41=4;
                }
                break;
            case DEFAULT:
                {
                alt41=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 41, 0, input);

                throw nvae;
            }

            switch (alt41) {
                case 1 :
                    // ASCollector.g3:1164:5: bindingDecl
                    {
                    pushFollow(FOLLOW_bindingDecl_in_directive6211);
                    bindingDecl72=bindingDecl();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, bindingDecl72.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1164:19: includeDirective
                    {
                    pushFollow(FOLLOW_includeDirective_in_directive6215);
                    includeDirective73=includeDirective();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, includeDirective73.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1164:38: useNamespaceDirective
                    {
                    pushFollow(FOLLOW_useNamespaceDirective_in_directive6219);
                    useNamespaceDirective74=useNamespaceDirective();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, useNamespaceDirective74.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:1164:62: i= importDeclaration
                    {
                    pushFollow(FOLLOW_importDeclaration_in_directive6225);
                    i=importDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, i.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:1164:84: defaultXMLNamespaceDirective
                    {
                    pushFollow(FOLLOW_defaultXMLNamespaceDirective_in_directive6229);
                    defaultXMLNamespaceDirective75=defaultXMLNamespaceDirective();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, defaultXMLNamespaceDirective75.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 35, directive_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "directive"

    public static class conditionalDirAndBindingDecls_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalDirAndBindingDecls"
    // ASCollector.g3:1167:1: conditionalDirAndBindingDecls : conditionalCompilerOption ( bindingDecl )* ;
    public final ASCollectorParser.conditionalDirAndBindingDecls_return conditionalDirAndBindingDecls() throws RecognitionException {
        ASCollectorParser.conditionalDirAndBindingDecls_return retval = new ASCollectorParser.conditionalDirAndBindingDecls_return();
        retval.start = input.LT(1);
        int conditionalDirAndBindingDecls_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.conditionalCompilerOption_return conditionalCompilerOption76 = null;

        ASCollectorParser.bindingDecl_return bindingDecl77 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return retval; }
            // ASCollector.g3:1168:2: ( conditionalCompilerOption ( bindingDecl )* )
            // ASCollector.g3:1170:4: conditionalCompilerOption ( bindingDecl )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_conditionalCompilerOption_in_conditionalDirAndBindingDecls6252);
            conditionalCompilerOption76=conditionalCompilerOption();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalCompilerOption76.getTree());
            if ( state.backtracking==0 ) {
              mStopStoringBindingDecls=true;
            }
            // ASCollector.g3:1172:4: ( bindingDecl )*
            loop42:
            do {
                int alt42=2;
                int LA42_0 = input.LA(1);

                if ( (LA42_0==LBRACK) ) {
                    alt42=1;
                }


                switch (alt42) {
            	case 1 :
            	    // ASCollector.g3:1172:6: bindingDecl
            	    {
            	    pushFollow(FOLLOW_bindingDecl_in_conditionalDirAndBindingDecls6268);
            	    bindingDecl77=bindingDecl();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bindingDecl77.getTree());

            	    }
            	    break;

            	default :
            	    break loop42;
                }
            } while (true);

            if ( state.backtracking==0 ) {
              mStopStoringBindingDecls=false;
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 36, conditionalDirAndBindingDecls_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "conditionalDirAndBindingDecls"

    public static class xmlKeyword_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "xmlKeyword"
    // ASCollector.g3:1176:1: xmlKeyword : {...}?I= IDENTIFIER ;
    public final ASCollectorParser.xmlKeyword_return xmlKeyword() throws RecognitionException {
        ASCollectorParser.xmlKeyword_return retval = new ASCollectorParser.xmlKeyword_return();
        retval.start = input.LT(1);
        int xmlKeyword_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;

        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return retval; }
            // ASCollector.g3:1177:2: ({...}?I= IDENTIFIER )
            // ASCollector.g3:1177:4: {...}?I= IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();

            if ( !((input.LT(1).getText().equalsIgnoreCase("xml"))) ) {
                if (state.backtracking>0) {state.failed=true; return retval;}
                throw new FailedPredicateException(input, "xmlKeyword", "input.LT(1).getText().equalsIgnoreCase(\"xml\")");
            }
            I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_xmlKeyword6291); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 37, xmlKeyword_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "xmlKeyword"

    public static class conditionalCompilerOption_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalCompilerOption"
    // ASCollector.g3:1180:1: conditionalCompilerOption : identifierLiteral x= XML_NS_OP identifierLiteral ;
    public final ASCollectorParser.conditionalCompilerOption_return conditionalCompilerOption() throws RecognitionException {
        ASCollectorParser.conditionalCompilerOption_return retval = new ASCollectorParser.conditionalCompilerOption_return();
        retval.start = input.LT(1);
        int conditionalCompilerOption_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;
        ASCollectorParser.identifierLiteral_return identifierLiteral78 = null;

        ASCollectorParser.identifierLiteral_return identifierLiteral79 = null;


        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return retval; }
            // ASCollector.g3:1181:2: ( identifierLiteral x= XML_NS_OP identifierLiteral )
            // ASCollector.g3:1182:2: identifierLiteral x= XML_NS_OP identifierLiteral
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_identifierLiteral_in_conditionalCompilerOption6306);
            identifierLiteral78=identifierLiteral();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierLiteral78.getTree());
            x=(Token)match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_conditionalCompilerOption6310); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            x_tree = (Object)adaptor.create(x);
            adaptor.addChild(root_0, x_tree);
            }
            pushFollow(FOLLOW_identifierLiteral_in_conditionalCompilerOption6313);
            identifierLiteral79=identifierLiteral();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierLiteral79.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 38, conditionalCompilerOption_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "conditionalCompilerOption"

    public static class defaultXMLNamespaceDirective_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "defaultXMLNamespaceDirective"
    // ASCollector.g3:1185:1: defaultXMLNamespaceDirective : D= DEFAULT xmlKeyword N= NAMESPACE A= ASSIGN ex= assignmentExpression s= semic ;
    public final ASCollectorParser.defaultXMLNamespaceDirective_return defaultXMLNamespaceDirective() throws RecognitionException {
        ASCollectorParser.defaultXMLNamespaceDirective_return retval = new ASCollectorParser.defaultXMLNamespaceDirective_return();
        retval.start = input.LT(1);
        int defaultXMLNamespaceDirective_StartIndex = input.index();
        Object root_0 = null;

        Token D=null;
        Token N=null;
        Token A=null;
        ASCollectorParser.assignmentExpression_return ex = null;

        ASCollectorParser.semic_return s = null;

        ASCollectorParser.xmlKeyword_return xmlKeyword80 = null;


        Object D_tree=null;
        Object N_tree=null;
        Object A_tree=null;


        	DefaultNamespaceItem item=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return retval; }
            // ASCollector.g3:1189:2: (D= DEFAULT xmlKeyword N= NAMESPACE A= ASSIGN ex= assignmentExpression s= semic )
            // ASCollector.g3:1190:2: D= DEFAULT xmlKeyword N= NAMESPACE A= ASSIGN ex= assignmentExpression s= semic
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              item=new DefaultNamespaceItem();
            }
            D=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_defaultXMLNamespaceDirective6336); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            D_tree = (Object)adaptor.create(D);
            adaptor.addChild(root_0, D_tree);
            }
            if ( state.backtracking==0 ) {
              item.captureStartPos(D);captureHiddenTokens(item, D);
            }
            pushFollow(FOLLOW_xmlKeyword_in_defaultXMLNamespaceDirective6343);
            xmlKeyword80=xmlKeyword();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlKeyword80.getTree());
            N=(Token)match(input,NAMESPACE,FOLLOW_NAMESPACE_in_defaultXMLNamespaceDirective6351); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            N_tree = (Object)adaptor.create(N);
            adaptor.addChild(root_0, N_tree);
            }
            A=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_defaultXMLNamespaceDirective6357); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            A_tree = (Object)adaptor.create(A);
            adaptor.addChild(root_0, A_tree);
            }
            pushFollow(FOLLOW_assignmentExpression_in_defaultXMLNamespaceDirective6362);
            ex=assignmentExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, ex.getTree());
            if ( state.backtracking==0 ) {
              item.setNamespace(ex);
            }
            pushFollow(FOLLOW_semic_in_defaultXMLNamespaceDirective6369);
            s=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());
            if ( state.backtracking==0 ) {

              		if (s!=null)
              		{
              			item.captureEndPos(s);
              			capturePostHiddenTokens(item, s);
              		}
              		else
              		{
              			item.captureEndPos(ex);
              			capturePostHiddenTokens(item, ex);
              		}
              			
              		if (getFunctionRecord()!=null)
              		{} //throw away
              		else if (getClassRecord()!=null)
              		{
              			getClassRecord().addDefaultNamespace(item);
              		}
              		else
              		{
              			getCollector().addDefaultNamespace(item);
              		}
              	
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 39, defaultXMLNamespaceDirective_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "defaultXMLNamespaceDirective"

    public static class bindingDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bindingDecl"
    // ASCollector.g3:1221:1: bindingDecl : L= LBRACK ( XML_AT )? I= IDENTIFIER (L= LPAREN (b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )* )? R= RPAREN )? R= RBRACK (s= SEMI )? ;
    public final ASCollectorParser.bindingDecl_return bindingDecl() throws RecognitionException {
        ASCollectorParser.bindingDecl_return retval = new ASCollectorParser.bindingDecl_return();
        retval.start = input.LT(1);
        int bindingDecl_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token I=null;
        Token C=null;
        Token R=null;
        Token s=null;
        Token XML_AT81=null;
        ASCollectorParser.bindingDeclArg_return b1 = null;

        ASCollectorParser.bindingDeclArg_return b2 = null;


        Object L_tree=null;
        Object I_tree=null;
        Object C_tree=null;
        Object R_tree=null;
        Object s_tree=null;
        Object XML_AT81_tree=null;


        	MetadataItem item=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return retval; }
            // ASCollector.g3:1226:2: (L= LBRACK ( XML_AT )? I= IDENTIFIER (L= LPAREN (b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )* )? R= RPAREN )? R= RBRACK (s= SEMI )? )
            // ASCollector.g3:1226:4: L= LBRACK ( XML_AT )? I= IDENTIFIER (L= LPAREN (b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )* )? R= RPAREN )? R= RBRACK (s= SEMI )?
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_bindingDecl6393); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            if ( state.backtracking==0 ) {
              item=new MetadataItem();item.captureStartPos(L);captureHiddenTokens(item, L);
            }
            // ASCollector.g3:1228:5: ( XML_AT )?
            int alt43=2;
            int LA43_0 = input.LA(1);

            if ( (LA43_0==XML_AT) ) {
                alt43=1;
            }
            switch (alt43) {
                case 1 :
                    // ASCollector.g3:1228:6: XML_AT
                    {
                    XML_AT81=(Token)match(input,XML_AT,FOLLOW_XML_AT_in_bindingDecl6407); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    XML_AT81_tree = (Object)adaptor.create(XML_AT81);
                    adaptor.addChild(root_0, XML_AT81_tree);
                    }

                    }
                    break;

            }

            I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_bindingDecl6413); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }
            if ( state.backtracking==0 ) {
              item.setBindingType(I);
            }
            // ASCollector.g3:1230:5: (L= LPAREN (b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )* )? R= RPAREN )?
            int alt46=2;
            int LA46_0 = input.LA(1);

            if ( (LA46_0==LPAREN) ) {
                alt46=1;
            }
            switch (alt46) {
                case 1 :
                    // ASCollector.g3:1230:6: L= LPAREN (b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )* )? R= RPAREN
                    {
                    L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_bindingDecl6429); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    L_tree = (Object)adaptor.create(L);
                    adaptor.addChild(root_0, L_tree);
                    }
                    // ASCollector.g3:1231:8: (b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )* )?
                    int alt45=2;
                    int LA45_0 = input.LA(1);

                    if ( ((LA45_0>=AS && LA45_0<=STATIC)||(LA45_0>=PLUS && LA45_0<=STAR)||LA45_0==XML_AT||(LA45_0>=SINGLE_QUOTE_LITERAL && LA45_0<=DOUBLE_QUOTE_LITERAL)||LA45_0==HEX_NUMBER_LITERAL||LA45_0==DEC_NUMBER_LITERAL||LA45_0==IDENTIFIER) ) {
                        alt45=1;
                    }
                    switch (alt45) {
                        case 1 :
                            // ASCollector.g3:1231:9: b1= bindingDeclArg (C= COMMA b2= bindingDeclArg )*
                            {
                            pushFollow(FOLLOW_bindingDeclArg_in_bindingDecl6442);
                            b1=bindingDeclArg();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, b1.getTree());
                            if ( state.backtracking==0 ) {
                              item.addArg(b1);
                            }
                            // ASCollector.g3:1232:9: (C= COMMA b2= bindingDeclArg )*
                            loop44:
                            do {
                                int alt44=2;
                                int LA44_0 = input.LA(1);

                                if ( (LA44_0==COMMA) ) {
                                    alt44=1;
                                }


                                switch (alt44) {
                            	case 1 :
                            	    // ASCollector.g3:1232:10: C= COMMA b2= bindingDeclArg
                            	    {
                            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_bindingDecl6458); if (state.failed) return retval;
                            	    if ( state.backtracking==0 ) {
                            	    C_tree = (Object)adaptor.create(C);
                            	    adaptor.addChild(root_0, C_tree);
                            	    }
                            	    pushFollow(FOLLOW_bindingDeclArg_in_bindingDecl6462);
                            	    b2=bindingDeclArg();

                            	    state._fsp--;
                            	    if (state.failed) return retval;
                            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, b2.getTree());
                            	    if ( state.backtracking==0 ) {
                            	      item.addArg(b2);
                            	    }

                            	    }
                            	    break;

                            	default :
                            	    break loop44;
                                }
                            } while (true);


                            }
                            break;

                    }

                    R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_bindingDecl6494); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    R_tree = (Object)adaptor.create(R);
                    adaptor.addChild(root_0, R_tree);
                    }

                    }
                    break;

            }

            R=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_bindingDecl6515); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            // ASCollector.g3:1237:14: (s= SEMI )?
            int alt47=2;
            int LA47_0 = input.LA(1);

            if ( (LA47_0==SEMI) ) {
                int LA47_1 = input.LA(2);

                if ( (synpred124_ASCollector()) ) {
                    alt47=1;
                }
            }
            switch (alt47) {
                case 1 :
                    // ASCollector.g3:1237:15: s= SEMI
                    {
                    s=(Token)match(input,SEMI,FOLLOW_SEMI_in_bindingDecl6520); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    s_tree = (Object)adaptor.create(s);
                    adaptor.addChild(root_0, s_tree);
                    }

                    }
                    break;

            }

            if ( state.backtracking==0 ) {

              	   		if (!mStopStoringBindingDecls)
              	   		{
              	   			if (s!=null)
              	   			{
                 					item.captureEndPos(s);
                 					capturePostHiddenTokens(item, s);
                 				}
                 				else
                 				{
                 					item.captureEndPos(R);
                 					capturePostHiddenTokens(item, R);
                 				}
                 			
              	   			addMetadataItem(item);
              	   		}
              	   
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 40, bindingDecl_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bindingDecl"

    public static class includeDirective_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "includeDirective"
    // ASCollector.g3:1257:1: includeDirective : I= INCLUDE s= stringLiteral sem= semic ;
    public final ASCollectorParser.includeDirective_return includeDirective() throws RecognitionException {
        ASCollectorParser.includeDirective_return retval = new ASCollectorParser.includeDirective_return();
        retval.start = input.LT(1);
        int includeDirective_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        ASCollectorParser.stringLiteral_return s = null;

        ASCollectorParser.semic_return sem = null;


        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return retval; }
            // ASCollector.g3:1258:2: (I= INCLUDE s= stringLiteral sem= semic )
            // ASCollector.g3:1258:4: I= INCLUDE s= stringLiteral sem= semic
            {
            root_0 = (Object)adaptor.nil();

            I=(Token)match(input,INCLUDE,FOLLOW_INCLUDE_in_includeDirective6543); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }
            pushFollow(FOLLOW_stringLiteral_in_includeDirective6547);
            s=stringLiteral();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());
            pushFollow(FOLLOW_semic_in_includeDirective6551);
            sem=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, sem.getTree());
            if ( state.backtracking==0 ) {

              	    if (getFunctionRecord()==null) //make sure this is not inside a function
              	    {
              	 		IncludeItem item=new IncludeItem();
              	 		item.captureStartPos(I);
              	 		captureHiddenTokens(item, I);
              	 		item.setIncludeFile(s);
              	 		if (getClassRecord()!=null)
              	 		{
              	 			getClassRecord().addInclude(item);
              	 		}
              	 		else
              	 		{
              	 		    getCollector().addInclude(item);
              	 		}
              	 		if (sem!=null)
              	 		{
              	 			item.captureEndPos(sem);
              	 			capturePostHiddenTokens(item, sem);
              	 		}
              	 		else
              	 		{
              	 			item.captureEndPos(s);
              	 			capturePostHiddenTokens(item, s);
              	 		}
              	 	}
              	 
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 41, includeDirective_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "includeDirective"

    public static class bindingDeclArg_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bindingDeclArg"
    // ASCollector.g3:1288:1: bindingDeclArg : ( eitherIdentifier E= ASSIGN )? ( stringLiteral | ( PLUS | SUB )? numericLiteral | ( eitherIdentifier ( DOT eitherIdentifier )* ) ) ;
    public final ASCollectorParser.bindingDeclArg_return bindingDeclArg() throws RecognitionException {
        ASCollectorParser.bindingDeclArg_return retval = new ASCollectorParser.bindingDeclArg_return();
        retval.start = input.LT(1);
        int bindingDeclArg_StartIndex = input.index();
        Object root_0 = null;

        Token E=null;
        Token set84=null;
        Token DOT87=null;
        ASCollectorParser.eitherIdentifier_return eitherIdentifier82 = null;

        ASCollectorParser.stringLiteral_return stringLiteral83 = null;

        ASCollectorParser.numericLiteral_return numericLiteral85 = null;

        ASCollectorParser.eitherIdentifier_return eitherIdentifier86 = null;

        ASCollectorParser.eitherIdentifier_return eitherIdentifier88 = null;


        Object E_tree=null;
        Object set84_tree=null;
        Object DOT87_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return retval; }
            // ASCollector.g3:1289:2: ( ( eitherIdentifier E= ASSIGN )? ( stringLiteral | ( PLUS | SUB )? numericLiteral | ( eitherIdentifier ( DOT eitherIdentifier )* ) ) )
            // ASCollector.g3:1295:2: ( eitherIdentifier E= ASSIGN )? ( stringLiteral | ( PLUS | SUB )? numericLiteral | ( eitherIdentifier ( DOT eitherIdentifier )* ) )
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1295:2: ( eitherIdentifier E= ASSIGN )?
            int alt48=2;
            alt48 = dfa48.predict(input);
            switch (alt48) {
                case 1 :
                    // ASCollector.g3:1295:3: eitherIdentifier E= ASSIGN
                    {
                    pushFollow(FOLLOW_eitherIdentifier_in_bindingDeclArg6577);
                    eitherIdentifier82=eitherIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, eitherIdentifier82.getTree());
                    E=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_bindingDeclArg6582); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    E_tree = (Object)adaptor.create(E);
                    adaptor.addChild(root_0, E_tree);
                    }

                    }
                    break;

            }

            // ASCollector.g3:1296:2: ( stringLiteral | ( PLUS | SUB )? numericLiteral | ( eitherIdentifier ( DOT eitherIdentifier )* ) )
            int alt51=3;
            switch ( input.LA(1) ) {
            case SINGLE_QUOTE_LITERAL:
            case DOUBLE_QUOTE_LITERAL:
                {
                alt51=1;
                }
                break;
            case PLUS:
            case SUB:
            case HEX_NUMBER_LITERAL:
            case DEC_NUMBER_LITERAL:
                {
                alt51=2;
                }
                break;
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NATIVE:
            case NEW:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TO:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case INCLUDE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case STAR:
            case XML_AT:
            case IDENTIFIER:
                {
                alt51=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 51, 0, input);

                throw nvae;
            }

            switch (alt51) {
                case 1 :
                    // ASCollector.g3:1297:3: stringLiteral
                    {
                    pushFollow(FOLLOW_stringLiteral_in_bindingDeclArg6593);
                    stringLiteral83=stringLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, stringLiteral83.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1297:19: ( PLUS | SUB )? numericLiteral
                    {
                    // ASCollector.g3:1297:19: ( PLUS | SUB )?
                    int alt49=2;
                    int LA49_0 = input.LA(1);

                    if ( ((LA49_0>=PLUS && LA49_0<=SUB)) ) {
                        alt49=1;
                    }
                    switch (alt49) {
                        case 1 :
                            // ASCollector.g3:
                            {
                            set84=(Token)input.LT(1);
                            if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) {
                                input.consume();
                                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set84));
                                state.errorRecovery=false;state.failed=false;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                throw mse;
                            }


                            }
                            break;

                    }

                    pushFollow(FOLLOW_numericLiteral_in_bindingDeclArg6606);
                    numericLiteral85=numericLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, numericLiteral85.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1297:50: ( eitherIdentifier ( DOT eitherIdentifier )* )
                    {
                    // ASCollector.g3:1297:50: ( eitherIdentifier ( DOT eitherIdentifier )* )
                    // ASCollector.g3:1297:51: eitherIdentifier ( DOT eitherIdentifier )*
                    {
                    pushFollow(FOLLOW_eitherIdentifier_in_bindingDeclArg6611);
                    eitherIdentifier86=eitherIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, eitherIdentifier86.getTree());
                    // ASCollector.g3:1297:68: ( DOT eitherIdentifier )*
                    loop50:
                    do {
                        int alt50=2;
                        int LA50_0 = input.LA(1);

                        if ( (LA50_0==DOT) ) {
                            alt50=1;
                        }


                        switch (alt50) {
                    	case 1 :
                    	    // ASCollector.g3:1297:69: DOT eitherIdentifier
                    	    {
                    	    DOT87=(Token)match(input,DOT,FOLLOW_DOT_in_bindingDeclArg6614); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    DOT87_tree = (Object)adaptor.create(DOT87);
                    	    adaptor.addChild(root_0, DOT87_tree);
                    	    }
                    	    pushFollow(FOLLOW_eitherIdentifier_in_bindingDeclArg6616);
                    	    eitherIdentifier88=eitherIdentifier();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, eitherIdentifier88.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop50;
                        }
                    } while (true);


                    }


                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 42, bindingDeclArg_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bindingDeclArg"

    public static class interfaceDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "interfaceDeclaration"
    // ASCollector.g3:1305:1: interfaceDeclaration : i= INTERFACE name= type (e= EXTENDS typeList )? interfaceBody ;
    public final ASCollectorParser.interfaceDeclaration_return interfaceDeclaration() throws RecognitionException {
        ASCollectorParser.interfaceDeclaration_return retval = new ASCollectorParser.interfaceDeclaration_return();
        retval.start = input.LT(1);
        int interfaceDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token i=null;
        Token e=null;
        ASCollectorParser.type_return name = null;

        ASCollectorParser.typeList_return typeList89 = null;

        ASCollectorParser.interfaceBody_return interfaceBody90 = null;


        Object i_tree=null;
        Object e_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return retval; }
            // ASCollector.g3:1306:2: (i= INTERFACE name= type (e= EXTENDS typeList )? interfaceBody )
            // ASCollector.g3:1306:6: i= INTERFACE name= type (e= EXTENDS typeList )? interfaceBody
            {
            root_0 = (Object)adaptor.nil();

            i=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceDeclaration6644); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            i_tree = (Object)adaptor.create(i);
            adaptor.addChild(root_0, i_tree);
            }
            if ( state.backtracking==0 ) {

                			//TODO: look for existing asdoc comment in the hidden tokens before the 'class' keyword
              			ClassRecord rec=getClassRecord();
              			rec.captureStartPos(i);
              		
            }
            pushFollow(FOLLOW_type_in_interfaceDeclaration6663);
            name=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, name.getTree());
            if ( state.backtracking==0 ) {

              			getClassRecord().setName(name);
              		
            }
            // ASCollector.g3:1318:3: (e= EXTENDS typeList )?
            int alt52=2;
            int LA52_0 = input.LA(1);

            if ( (LA52_0==EXTENDS) ) {
                alt52=1;
            }
            switch (alt52) {
                case 1 :
                    // ASCollector.g3:1318:4: e= EXTENDS typeList
                    {
                    e=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_interfaceDeclaration6679); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    e_tree = (Object)adaptor.create(e);
                    adaptor.addChild(root_0, e_tree);
                    }
                    pushFollow(FOLLOW_typeList_in_interfaceDeclaration6682);
                    typeList89=typeList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, typeList89.getTree());

                    }
                    break;

            }

            pushFollow(FOLLOW_interfaceBody_in_interfaceDeclaration6695);
            interfaceBody90=interfaceBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceBody90.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 43, interfaceDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "interfaceDeclaration"

    public static class interfaceBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "interfaceBody"
    // ASCollector.g3:1322:1: interfaceBody : l= LCURLY ( interfaceElement )* r= RCURLY ;
    public final ASCollectorParser.interfaceBody_return interfaceBody() throws RecognitionException {
        ASCollectorParser.interfaceBody_return retval = new ASCollectorParser.interfaceBody_return();
        retval.start = input.LT(1);
        int interfaceBody_StartIndex = input.index();
        Object root_0 = null;

        Token l=null;
        Token r=null;
        ASCollectorParser.interfaceElement_return interfaceElement91 = null;


        Object l_tree=null;
        Object r_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return retval; }
            // ASCollector.g3:1323:2: (l= LCURLY ( interfaceElement )* r= RCURLY )
            // ASCollector.g3:1323:6: l= LCURLY ( interfaceElement )* r= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            l=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_interfaceBody6711); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            l_tree = (Object)adaptor.create(l);
            adaptor.addChild(root_0, l_tree);
            }
            if ( state.backtracking==0 ) {

              	    	getClassRecord().setBodyStart(l);
              	    
            }
            // ASCollector.g3:1327:6: ( interfaceElement )*
            loop53:
            do {
                int alt53=2;
                int LA53_0 = input.LA(1);

                if ( ((LA53_0>=AS && LA53_0<=LCURLY)||LA53_0==LPAREN||LA53_0==LBRACK||LA53_0==LT||(LA53_0>=PLUS && LA53_0<=STAR)||(LA53_0>=INC && LA53_0<=DEC)||(LA53_0>=NOT && LA53_0<=INV)||(LA53_0>=XML_AT && LA53_0<=XML_LS_STD)||(LA53_0>=SINGLE_QUOTE_LITERAL && LA53_0<=DOUBLE_QUOTE_LITERAL)||LA53_0==REGULAR_EXPR_LITERAL||LA53_0==HEX_NUMBER_LITERAL||LA53_0==DEC_NUMBER_LITERAL||LA53_0==IDENTIFIER||(LA53_0>=XML_COMMENT && LA53_0<=XML_PI)) ) {
                    alt53=1;
                }


                switch (alt53) {
            	case 1 :
            	    // ASCollector.g3:0:0: interfaceElement
            	    {
            	    pushFollow(FOLLOW_interfaceElement_in_interfaceBody6727);
            	    interfaceElement91=interfaceElement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceElement91.getTree());

            	    }
            	    break;

            	default :
            	    break loop53;
                }
            } while (true);

            r=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_interfaceBody6745); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            r_tree = (Object)adaptor.create(r);
            adaptor.addChild(root_0, r_tree);
            }
            if ( state.backtracking==0 ) {
              getClassRecord().setBodyEnd(r);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 44, interfaceBody_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "interfaceBody"

    public static class classDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classDeclaration"
    // ASCollector.g3:1333:1: classDeclaration : c= CLASS name= type (E= EXTENDS superclass= type )? (I= IMPLEMENTS implemented= typeList )? classBody ;
    public final ASCollectorParser.classDeclaration_return classDeclaration() throws RecognitionException {
        ASCollectorParser.classDeclaration_return retval = new ASCollectorParser.classDeclaration_return();
        retval.start = input.LT(1);
        int classDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token c=null;
        Token E=null;
        Token I=null;
        ASCollectorParser.type_return name = null;

        ASCollectorParser.type_return superclass = null;

        ASCollectorParser.typeList_return implemented = null;

        ASCollectorParser.classBody_return classBody92 = null;


        Object c_tree=null;
        Object E_tree=null;
        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return retval; }
            // ASCollector.g3:1334:2: (c= CLASS name= type (E= EXTENDS superclass= type )? (I= IMPLEMENTS implemented= typeList )? classBody )
            // ASCollector.g3:1335:3: c= CLASS name= type (E= EXTENDS superclass= type )? (I= IMPLEMENTS implemented= typeList )? classBody
            {
            root_0 = (Object)adaptor.nil();

            c=(Token)match(input,CLASS,FOLLOW_CLASS_in_classDeclaration6773); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            c_tree = (Object)adaptor.create(c);
            adaptor.addChild(root_0, c_tree);
            }
            if ( state.backtracking==0 ) {

                			//TODO: look for existing asdoc comment in the hidden tokens before the 'class' keyword
              			ClassRecord rec=getClassRecord();
              			rec.captureStartPos(c);
              		
            }
            pushFollow(FOLLOW_type_in_classDeclaration6785);
            name=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, name.getTree());
            if ( state.backtracking==0 ) {

              			getClassRecord().setName(name);
              		
            }
            // ASCollector.g3:1345:3: (E= EXTENDS superclass= type )?
            int alt54=2;
            int LA54_0 = input.LA(1);

            if ( (LA54_0==EXTENDS) ) {
                alt54=1;
            }
            switch (alt54) {
                case 1 :
                    // ASCollector.g3:1345:5: E= EXTENDS superclass= type
                    {
                    E=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_classDeclaration6798); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    E_tree = (Object)adaptor.create(E);
                    adaptor.addChild(root_0, E_tree);
                    }
                    pushFollow(FOLLOW_type_in_classDeclaration6803);
                    superclass=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, superclass.getTree());
                    if ( state.backtracking==0 ) {

                      				getClassRecord().setExtends(superclass);
                      			
                    }

                    }
                    break;

            }

            // ASCollector.g3:1350:3: (I= IMPLEMENTS implemented= typeList )?
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( (LA55_0==IMPLEMENTS) ) {
                alt55=1;
            }
            switch (alt55) {
                case 1 :
                    // ASCollector.g3:1351:4: I= IMPLEMENTS implemented= typeList
                    {
                    I=(Token)match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_classDeclaration6826); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }
                    if ( state.backtracking==0 ) {
                      setTextHandler(getClassRecord().getImplementsHandler());
                    }
                    pushFollow(FOLLOW_typeList_in_classDeclaration6832);
                    implemented=typeList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, implemented.getTree());
                    if ( state.backtracking==0 ) {
                      clearTextHandler();
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_classBody_in_classDeclaration6851);
            classBody92=classBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, classBody92.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 45, classDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "classDeclaration"

    public static class classBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classBody"
    // ASCollector.g3:1358:1: classBody : L= LCURLY ( classBodyElement )* R= RCURLY ;
    public final ASCollectorParser.classBody_return classBody() throws RecognitionException {
        ASCollectorParser.classBody_return retval = new ASCollectorParser.classBody_return();
        retval.start = input.LT(1);
        int classBody_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.classBodyElement_return classBodyElement93 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return retval; }
            // ASCollector.g3:1359:2: (L= LCURLY ( classBodyElement )* R= RCURLY )
            // ASCollector.g3:1359:6: L= LCURLY ( classBodyElement )* R= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_classBody6880); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            if ( state.backtracking==0 ) {

              	    	getClassRecord().setBodyStart(L);
              	    
            }
            // ASCollector.g3:1364:3: ( classBodyElement )*
            loop56:
            do {
                int alt56=2;
                int LA56_0 = input.LA(1);

                if ( ((LA56_0>=AS && LA56_0<=LCURLY)||LA56_0==LPAREN||LA56_0==LBRACK||LA56_0==LT||(LA56_0>=PLUS && LA56_0<=STAR)||(LA56_0>=INC && LA56_0<=DEC)||(LA56_0>=NOT && LA56_0<=INV)||(LA56_0>=XML_AT && LA56_0<=XML_LS_STD)||(LA56_0>=SINGLE_QUOTE_LITERAL && LA56_0<=DOUBLE_QUOTE_LITERAL)||LA56_0==REGULAR_EXPR_LITERAL||LA56_0==HEX_NUMBER_LITERAL||LA56_0==DEC_NUMBER_LITERAL||LA56_0==IDENTIFIER||(LA56_0>=XML_COMMENT && LA56_0<=XML_PI)) ) {
                    alt56=1;
                }


                switch (alt56) {
            	case 1 :
            	    // ASCollector.g3:0:0: classBodyElement
            	    {
            	    pushFollow(FOLLOW_classBodyElement_in_classBody6897);
            	    classBodyElement93=classBodyElement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, classBodyElement93.getTree());

            	    }
            	    break;

            	default :
            	    break loop56;
                }
            } while (true);

            R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_classBody6909); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            if ( state.backtracking==0 ) {
              getClassRecord().setBodyEnd(R);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 46, classBody_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "classBody"

    public static class classBodyElement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classBodyElement"
    // ASCollector.g3:1373:1: classBodyElement : ( ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( classBodyElement )* RCURLY | propertyDeclaration | functionDeclaration[true] | directive | statement );
    public final ASCollectorParser.classBodyElement_return classBodyElement() throws RecognitionException {
        ASCollectorParser.classBodyElement_return retval = new ASCollectorParser.classBodyElement_return();
        retval.start = input.LT(1);
        int classBodyElement_StartIndex = input.index();
        Object root_0 = null;

        Token LCURLY95=null;
        Token RCURLY97=null;
        ASCollectorParser.conditionalCompilerOption_return conditionalCompilerOption94 = null;

        ASCollectorParser.classBodyElement_return classBodyElement96 = null;

        ASCollectorParser.propertyDeclaration_return propertyDeclaration98 = null;

        ASCollectorParser.functionDeclaration_return functionDeclaration99 = null;

        ASCollectorParser.directive_return directive100 = null;

        ASCollectorParser.statement_return statement101 = null;


        Object LCURLY95_tree=null;
        Object RCURLY97_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return retval; }
            // ASCollector.g3:1374:5: ( ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( classBodyElement )* RCURLY | propertyDeclaration | functionDeclaration[true] | directive | statement )
            int alt58=5;
            alt58 = dfa58.predict(input);
            switch (alt58) {
                case 1 :
                    // ASCollector.g3:1374:9: ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( classBodyElement )* RCURLY
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_conditionalCompilerOption_in_classBodyElement6939);
                    conditionalCompilerOption94=conditionalCompilerOption();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalCompilerOption94.getTree());
                    LCURLY95=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_classBodyElement6941); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    LCURLY95_tree = (Object)adaptor.create(LCURLY95);
                    adaptor.addChild(root_0, LCURLY95_tree);
                    }
                    // ASCollector.g3:1374:78: ( classBodyElement )*
                    loop57:
                    do {
                        int alt57=2;
                        int LA57_0 = input.LA(1);

                        if ( ((LA57_0>=AS && LA57_0<=LCURLY)||LA57_0==LPAREN||LA57_0==LBRACK||LA57_0==LT||(LA57_0>=PLUS && LA57_0<=STAR)||(LA57_0>=INC && LA57_0<=DEC)||(LA57_0>=NOT && LA57_0<=INV)||(LA57_0>=XML_AT && LA57_0<=XML_LS_STD)||(LA57_0>=SINGLE_QUOTE_LITERAL && LA57_0<=DOUBLE_QUOTE_LITERAL)||LA57_0==REGULAR_EXPR_LITERAL||LA57_0==HEX_NUMBER_LITERAL||LA57_0==DEC_NUMBER_LITERAL||LA57_0==IDENTIFIER||(LA57_0>=XML_COMMENT && LA57_0<=XML_PI)) ) {
                            alt57=1;
                        }


                        switch (alt57) {
                    	case 1 :
                    	    // ASCollector.g3:0:0: classBodyElement
                    	    {
                    	    pushFollow(FOLLOW_classBodyElement_in_classBodyElement6943);
                    	    classBodyElement96=classBodyElement();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, classBodyElement96.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop57;
                        }
                    } while (true);

                    RCURLY97=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_classBodyElement6946); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    RCURLY97_tree = (Object)adaptor.create(RCURLY97);
                    adaptor.addChild(root_0, RCURLY97_tree);
                    }
                    if ( state.backtracking==0 ) {
                      mSeenConditionalMemberBlock=true;
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1375:8: propertyDeclaration
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_propertyDeclaration_in_classBodyElement6958);
                    propertyDeclaration98=propertyDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyDeclaration98.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1375:30: functionDeclaration[true]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_functionDeclaration_in_classBodyElement6962);
                    functionDeclaration99=functionDeclaration(true);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, functionDeclaration99.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:1375:58: directive
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_directive_in_classBodyElement6967);
                    directive100=directive();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, directive100.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:1375:70: statement
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_statement_in_classBodyElement6971);
                    statement101=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement101.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 47, classBodyElement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "classBodyElement"

    public static class interfaceElement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "interfaceElement"
    // ASCollector.g3:1378:1: interfaceElement : ( ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( interfaceElement )* RCURLY | propertyDeclaration | interfaceFunctionDeclaration[true] | directive | statement );
    public final ASCollectorParser.interfaceElement_return interfaceElement() throws RecognitionException {
        ASCollectorParser.interfaceElement_return retval = new ASCollectorParser.interfaceElement_return();
        retval.start = input.LT(1);
        int interfaceElement_StartIndex = input.index();
        Object root_0 = null;

        Token LCURLY103=null;
        Token RCURLY105=null;
        ASCollectorParser.conditionalCompilerOption_return conditionalCompilerOption102 = null;

        ASCollectorParser.interfaceElement_return interfaceElement104 = null;

        ASCollectorParser.propertyDeclaration_return propertyDeclaration106 = null;

        ASCollectorParser.interfaceFunctionDeclaration_return interfaceFunctionDeclaration107 = null;

        ASCollectorParser.directive_return directive108 = null;

        ASCollectorParser.statement_return statement109 = null;


        Object LCURLY103_tree=null;
        Object RCURLY105_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return retval; }
            // ASCollector.g3:1379:5: ( ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( interfaceElement )* RCURLY | propertyDeclaration | interfaceFunctionDeclaration[true] | directive | statement )
            int alt60=5;
            alt60 = dfa60.predict(input);
            switch (alt60) {
                case 1 :
                    // ASCollector.g3:1379:9: ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( interfaceElement )* RCURLY
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_conditionalCompilerOption_in_interfaceElement6993);
                    conditionalCompilerOption102=conditionalCompilerOption();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalCompilerOption102.getTree());
                    LCURLY103=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_interfaceElement6995); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    LCURLY103_tree = (Object)adaptor.create(LCURLY103);
                    adaptor.addChild(root_0, LCURLY103_tree);
                    }
                    // ASCollector.g3:1379:78: ( interfaceElement )*
                    loop59:
                    do {
                        int alt59=2;
                        int LA59_0 = input.LA(1);

                        if ( ((LA59_0>=AS && LA59_0<=LCURLY)||LA59_0==LPAREN||LA59_0==LBRACK||LA59_0==LT||(LA59_0>=PLUS && LA59_0<=STAR)||(LA59_0>=INC && LA59_0<=DEC)||(LA59_0>=NOT && LA59_0<=INV)||(LA59_0>=XML_AT && LA59_0<=XML_LS_STD)||(LA59_0>=SINGLE_QUOTE_LITERAL && LA59_0<=DOUBLE_QUOTE_LITERAL)||LA59_0==REGULAR_EXPR_LITERAL||LA59_0==HEX_NUMBER_LITERAL||LA59_0==DEC_NUMBER_LITERAL||LA59_0==IDENTIFIER||(LA59_0>=XML_COMMENT && LA59_0<=XML_PI)) ) {
                            alt59=1;
                        }


                        switch (alt59) {
                    	case 1 :
                    	    // ASCollector.g3:0:0: interfaceElement
                    	    {
                    	    pushFollow(FOLLOW_interfaceElement_in_interfaceElement6997);
                    	    interfaceElement104=interfaceElement();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceElement104.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop59;
                        }
                    } while (true);

                    RCURLY105=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_interfaceElement7000); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    RCURLY105_tree = (Object)adaptor.create(RCURLY105);
                    adaptor.addChild(root_0, RCURLY105_tree);
                    }
                    if ( state.backtracking==0 ) {
                      mSeenConditionalMemberBlock=true;
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1380:8: propertyDeclaration
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_propertyDeclaration_in_interfaceElement7016);
                    propertyDeclaration106=propertyDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyDeclaration106.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1380:30: interfaceFunctionDeclaration[true]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_interfaceFunctionDeclaration_in_interfaceElement7020);
                    interfaceFunctionDeclaration107=interfaceFunctionDeclaration(true);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceFunctionDeclaration107.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:1380:67: directive
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_directive_in_interfaceElement7025);
                    directive108=directive();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, directive108.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:1380:79: statement
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_statement_in_interfaceElement7029);
                    statement109=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement109.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 48, interfaceElement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "interfaceElement"

    public static class interfaceFunctionDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "interfaceFunctionDeclaration"
    // ASCollector.g3:1389:1: interfaceFunctionDeclaration[boolean store] : (c= conditionalDirAndBindingDecls )? (m= memberModifiers[func] )? F= FUNCTION (S= SET | G= GET )? (I= IDENTIFIER | nq= notQuiteReservedWord ) f= formalParameterList[func] (C= COLON t= type )? s= semic ;
    public final ASCollectorParser.interfaceFunctionDeclaration_return interfaceFunctionDeclaration(boolean store) throws RecognitionException {
        ASCollectorParser.interfaceFunctionDeclaration_return retval = new ASCollectorParser.interfaceFunctionDeclaration_return();
        retval.start = input.LT(1);
        int interfaceFunctionDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token F=null;
        Token S=null;
        Token G=null;
        Token I=null;
        Token C=null;
        ASCollectorParser.conditionalDirAndBindingDecls_return c = null;

        ASCollectorParser.memberModifiers_return m = null;

        ASCollectorParser.notQuiteReservedWord_return nq = null;

        ASCollectorParser.formalParameterList_return f = null;

        ASCollectorParser.type_return t = null;

        ASCollectorParser.semic_return s = null;


        Object F_tree=null;
        Object S_tree=null;
        Object G_tree=null;
        Object I_tree=null;
        Object C_tree=null;


        	FunctionRecord func=null;
        	int startPos=(-1);
        	int endPos=(-1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return retval; }
            // ASCollector.g3:1396:5: ( (c= conditionalDirAndBindingDecls )? (m= memberModifiers[func] )? F= FUNCTION (S= SET | G= GET )? (I= IDENTIFIER | nq= notQuiteReservedWord ) f= formalParameterList[func] (C= COLON t= type )? s= semic )
            // ASCollector.g3:1397:6: (c= conditionalDirAndBindingDecls )? (m= memberModifiers[func] )? F= FUNCTION (S= SET | G= GET )? (I= IDENTIFIER | nq= notQuiteReservedWord ) f= formalParameterList[func] (C= COLON t= type )? s= semic
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              func=new FunctionRecord();
                  	 if (store)
                  	 {
                  	 	setCurrentFunction(func);
                  	 	flushMetatags(func);
                  	 }
                  	
            }
            // ASCollector.g3:1404:9: (c= conditionalDirAndBindingDecls )?
            int alt61=2;
            switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA61_1 = input.LA(2);

                    if ( (LA61_1==XML_NS_OP) ) {
                        alt61=1;
                    }
                    }
                    break;
                case NATIVE:
                case DYNAMIC:
                case FINAL:
                case OVERRIDE:
                case STATIC:
                    {
                    int LA61_2 = input.LA(2);

                    if ( (LA61_2==XML_NS_OP) ) {
                        alt61=1;
                    }
                    }
                    break;
                case TO:
                case EACH:
                case GET:
                case SET:
                case NAMESPACE:
                    {
                    alt61=1;
                    }
                    break;
            }

            switch (alt61) {
                case 1 :
                    // ASCollector.g3:1404:10: c= conditionalDirAndBindingDecls
                    {
                    pushFollow(FOLLOW_conditionalDirAndBindingDecls_in_interfaceFunctionDeclaration7080);
                    c=conditionalDirAndBindingDecls();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, c.getTree());
                    if ( state.backtracking==0 ) {
                      func.captureStartPos(c);
                    }

                    }
                    break;

            }

            // ASCollector.g3:1407:6: (m= memberModifiers[func] )?
            int alt62=2;
            int LA62_0 = input.LA(1);

            if ( (LA62_0==INTERNAL||LA62_0==NATIVE||(LA62_0>=PRIVATE && LA62_0<=PUBLIC)||(LA62_0>=DYNAMIC && LA62_0<=STATIC)||LA62_0==IDENTIFIER) ) {
                alt62=1;
            }
            switch (alt62) {
                case 1 :
                    // ASCollector.g3:1407:7: m= memberModifiers[func]
                    {
                    pushFollow(FOLLOW_memberModifiers_in_interfaceFunctionDeclaration7114);
                    m=memberModifiers(func);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, m.getTree());
                    if ( state.backtracking==0 ) {
                      func.captureStartPos(m);
                    }

                    }
                    break;

            }

            F=(Token)match(input,FUNCTION,FOLLOW_FUNCTION_in_interfaceFunctionDeclaration7141); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            F_tree = (Object)adaptor.create(F);
            adaptor.addChild(root_0, F_tree);
            }
            if ( state.backtracking==0 ) {

                       	func.captureStartPos(F);
                       	if (c!=null)
                       		captureHiddenTokens(func, c);
                       	else if (m!=null)
                       		captureHiddenTokens(func, m);
                  	    else
                  		    captureHiddenTokens(func, F);
                      
            }
            // ASCollector.g3:1420:5: (S= SET | G= GET )?
            int alt63=3;
            int LA63_0 = input.LA(1);

            if ( (LA63_0==SET) ) {
                int LA63_1 = input.LA(2);

                if ( (LA63_1==NATIVE||LA63_1==TO||(LA63_1>=EACH && LA63_1<=NAMESPACE)||(LA63_1>=DYNAMIC && LA63_1<=STATIC)||LA63_1==IDENTIFIER) ) {
                    alt63=1;
                }
            }
            else if ( (LA63_0==GET) ) {
                int LA63_2 = input.LA(2);

                if ( (LA63_2==NATIVE||LA63_2==TO||(LA63_2>=EACH && LA63_2<=NAMESPACE)||(LA63_2>=DYNAMIC && LA63_2<=STATIC)||LA63_2==IDENTIFIER) ) {
                    alt63=2;
                }
            }
            switch (alt63) {
                case 1 :
                    // ASCollector.g3:1420:9: S= SET
                    {
                    S=(Token)match(input,SET,FOLLOW_SET_in_interfaceFunctionDeclaration7164); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }
                    if ( state.backtracking==0 ) {
                      func.setType(FunctionRecord.Type_Setter);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1421:9: G= GET
                    {
                    G=(Token)match(input,GET,FOLLOW_GET_in_interfaceFunctionDeclaration7179); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    G_tree = (Object)adaptor.create(G);
                    adaptor.addChild(root_0, G_tree);
                    }
                    if ( state.backtracking==0 ) {
                      func.setType(FunctionRecord.Type_Getter);
                    }

                    }
                    break;

            }

            // ASCollector.g3:1423:5: (I= IDENTIFIER | nq= notQuiteReservedWord )
            int alt64=2;
            int LA64_0 = input.LA(1);

            if ( (LA64_0==IDENTIFIER) ) {
                alt64=1;
            }
            else if ( (LA64_0==NATIVE||LA64_0==TO||(LA64_0>=EACH && LA64_0<=NAMESPACE)||(LA64_0>=DYNAMIC && LA64_0<=STATIC)) ) {
                alt64=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 64, 0, input);

                throw nvae;
            }
            switch (alt64) {
                case 1 :
                    // ASCollector.g3:1423:9: I= IDENTIFIER
                    {
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceFunctionDeclaration7201); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }
                    if ( state.backtracking==0 ) {
                      func.setName(I);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1424:9: nq= notQuiteReservedWord
                    {
                    pushFollow(FOLLOW_notQuiteReservedWord_in_interfaceFunctionDeclaration7215);
                    nq=notQuiteReservedWord();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nq.getTree());
                    if ( state.backtracking==0 ) {
                      func.setName(nq);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_formalParameterList_in_interfaceFunctionDeclaration7233);
            f=formalParameterList(func);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, f.getTree());
            // ASCollector.g3:1427:5: (C= COLON t= type )?
            int alt65=2;
            int LA65_0 = input.LA(1);

            if ( (LA65_0==COLON) ) {
                alt65=1;
            }
            switch (alt65) {
                case 1 :
                    // ASCollector.g3:1427:6: C= COLON t= type
                    {
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_interfaceFunctionDeclaration7244); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_type_in_interfaceFunctionDeclaration7249);
                    t=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree());
                    if ( state.backtracking==0 ) {
                      func.setReturnType(t);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_interfaceFunctionDeclaration7262);
            s=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());
            if ( state.backtracking==0 ) {

                  	if (s!=null)
                  	{
                  		func.captureEndPos(s);
                  		capturePostHiddenTokens(func, s);
                  	}
                  	else if (t!=null)
                  	{
                  		func.captureEndPos(t);
                  		capturePostHiddenTokens(func, t);
                  	}
                  	else
                  	{
                  	    func.captureEndPos(f);
                  	    capturePostHiddenTokens(func, f);
                  	}
                  
            }
            if ( state.backtracking==0 ) {

                  	if (store)
                  	{
                  		if (getClassRecord()!=null)
                  		{
                  			getClassRecord().addFunctionRecord(func); 
                  		}
                  		else
                  		{
                  			getCollector().addFunctionRecord(func);
                  		}
                  	}
                  	setCurrentFunction(null);
                  
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 49, interfaceFunctionDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "interfaceFunctionDeclaration"

    public static class propertyDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "propertyDeclaration"
    // ASCollector.g3:1466:1: propertyDeclaration : (c= conditionalDirAndBindingDecls )? (m= memberModifiers[rec] )? (v= variableStatement[rec] | constVar= constantVarStatement[rec] | ns= namespaceDirective[rec] ) ;
    public final ASCollectorParser.propertyDeclaration_return propertyDeclaration() throws RecognitionException {
        ASCollectorParser.propertyDeclaration_return retval = new ASCollectorParser.propertyDeclaration_return();
        retval.start = input.LT(1);
        int propertyDeclaration_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.conditionalDirAndBindingDecls_return c = null;

        ASCollectorParser.memberModifiers_return m = null;

        ASCollectorParser.variableStatement_return v = null;

        ASCollectorParser.constantVarStatement_return constVar = null;

        ASCollectorParser.namespaceDirective_return ns = null;




        	PropertyLine rec=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return retval; }
            // ASCollector.g3:1471:2: ( (c= conditionalDirAndBindingDecls )? (m= memberModifiers[rec] )? (v= variableStatement[rec] | constVar= constantVarStatement[rec] | ns= namespaceDirective[rec] ) )
            // ASCollector.g3:1472:3: (c= conditionalDirAndBindingDecls )? (m= memberModifiers[rec] )? (v= variableStatement[rec] | constVar= constantVarStatement[rec] | ns= namespaceDirective[rec] )
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              rec=new PropertyLine();
            }
            if ( state.backtracking==0 ) {
              flushMetatags(rec);
            }
            // ASCollector.g3:1475:3: (c= conditionalDirAndBindingDecls )?
            int alt66=2;
            switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA66_1 = input.LA(2);

                    if ( (LA66_1==XML_NS_OP) ) {
                        alt66=1;
                    }
                    }
                    break;
                case NATIVE:
                case DYNAMIC:
                case FINAL:
                case OVERRIDE:
                case STATIC:
                    {
                    int LA66_2 = input.LA(2);

                    if ( (LA66_2==XML_NS_OP) ) {
                        alt66=1;
                    }
                    }
                    break;
                case NAMESPACE:
                    {
                    int LA66_3 = input.LA(2);

                    if ( (LA66_3==XML_NS_OP) ) {
                        alt66=1;
                    }
                    }
                    break;
                case TO:
                case EACH:
                case GET:
                case SET:
                    {
                    alt66=1;
                    }
                    break;
            }

            switch (alt66) {
                case 1 :
                    // ASCollector.g3:1475:4: c= conditionalDirAndBindingDecls
                    {
                    pushFollow(FOLLOW_conditionalDirAndBindingDecls_in_propertyDeclaration7316);
                    c=conditionalDirAndBindingDecls();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, c.getTree());
                    if ( state.backtracking==0 ) {
                      rec.captureStartPos(c);
                      			 captureHiddenTokens(rec, c);
                      			
                    }

                    }
                    break;

            }

            // ASCollector.g3:1481:3: (m= memberModifiers[rec] )?
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==IDENTIFIER) ) {
                int LA67_1 = input.LA(2);

                if ( (synpred153_ASCollector()) ) {
                    alt67=1;
                }
            }
            else if ( (LA67_0==INTERNAL||LA67_0==NATIVE||(LA67_0>=PRIVATE && LA67_0<=PUBLIC)||(LA67_0>=DYNAMIC && LA67_0<=STATIC)) ) {
                alt67=1;
            }
            switch (alt67) {
                case 1 :
                    // ASCollector.g3:1481:4: m= memberModifiers[rec]
                    {
                    pushFollow(FOLLOW_memberModifiers_in_propertyDeclaration7338);
                    m=memberModifiers(rec);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, m.getTree());
                    if ( state.backtracking==0 ) {
                      rec.captureStartPos(m);
                      			 if (c==null)
                      			    captureHiddenTokens(rec, m);
                      			
                    }

                    }
                    break;

            }

            // ASCollector.g3:1488:4: (v= variableStatement[rec] | constVar= constantVarStatement[rec] | ns= namespaceDirective[rec] )
            int alt68=3;
            switch ( input.LA(1) ) {
            case VAR:
            case IDENTIFIER:
                {
                alt68=1;
                }
                break;
            case CONST:
                {
                alt68=2;
                }
                break;
            case NAMESPACE:
                {
                alt68=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 68, 0, input);

                throw nvae;
            }

            switch (alt68) {
                case 1 :
                    // ASCollector.g3:1488:5: v= variableStatement[rec]
                    {
                    pushFollow(FOLLOW_variableStatement_in_propertyDeclaration7361);
                    v=variableStatement(rec);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, v.getTree());
                    if ( state.backtracking==0 ) {
                      rec.capturePositions(v); capturePostHiddenTokens(rec, v);
                      		   if (c==null && m==null)
                      		   		captureHiddenTokens(rec, v);
                      		  
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1493:5: constVar= constantVarStatement[rec]
                    {
                    pushFollow(FOLLOW_constantVarStatement_in_propertyDeclaration7377);
                    constVar=constantVarStatement(rec);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, constVar.getTree());
                    if ( state.backtracking==0 ) {
                      rec.capturePositions(constVar); capturePostHiddenTokens(rec, constVar);
                      		   if (c==null && m==null)
                      		   		captureHiddenTokens(rec, constVar);
                      		  
                    }

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1498:5: ns= namespaceDirective[rec]
                    {
                    pushFollow(FOLLOW_namespaceDirective_in_propertyDeclaration7393);
                    ns=namespaceDirective(rec);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, ns.getTree());
                    if ( state.backtracking==0 ) {
                      rec.capturePositions(ns); rec.setIsNamespace(true); capturePostHiddenTokens(rec, ns);
                        		   if (c==null && m==null)
                      		   		captureHiddenTokens(rec, ns);
                      		  
                    }

                    }
                    break;

            }

            if ( state.backtracking==0 ) {

              			if (getClassRecord()!=null)
              			{
              				if (ns!=null)
              					getClassRecord().addNamespace(rec);
              				else
              					getClassRecord().addProperty(rec);
              			}
              			else
              			{
              				if (ns!=null)
              					getCollector().addDefinedNamespace(rec);
              				else
              					getCollector().addPropertyRecord(rec);
              			}
              		
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 50, propertyDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "propertyDeclaration"

    public static class functionDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "functionDeclaration"
    // ASCollector.g3:1527:1: functionDeclaration[boolean store] : (c= conditionalDirAndBindingDecls )? (m= memberModifiers[func] )? key= FUNCTION ( ( SET | GET ) )? (I= IDENTIFIER | nq= notQuiteReservedWord ) formalParameterList[func] (C= COLON t= type )? body= functionBody ;
    public final ASCollectorParser.functionDeclaration_return functionDeclaration(boolean store) throws RecognitionException {
        ASCollectorParser.functionDeclaration_return retval = new ASCollectorParser.functionDeclaration_return();
        retval.start = input.LT(1);
        int functionDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token key=null;
        Token I=null;
        Token C=null;
        Token SET110=null;
        Token GET111=null;
        ASCollectorParser.conditionalDirAndBindingDecls_return c = null;

        ASCollectorParser.memberModifiers_return m = null;

        ASCollectorParser.notQuiteReservedWord_return nq = null;

        ASCollectorParser.type_return t = null;

        ASCollectorParser.functionBody_return body = null;

        ASCollectorParser.formalParameterList_return formalParameterList112 = null;


        Object key_tree=null;
        Object I_tree=null;
        Object C_tree=null;
        Object SET110_tree=null;
        Object GET111_tree=null;


        	FunctionRecord func=null;
        	int startPos=(-1);
        	int endPos=(-1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return retval; }
            // ASCollector.g3:1534:5: ( (c= conditionalDirAndBindingDecls )? (m= memberModifiers[func] )? key= FUNCTION ( ( SET | GET ) )? (I= IDENTIFIER | nq= notQuiteReservedWord ) formalParameterList[func] (C= COLON t= type )? body= functionBody )
            // ASCollector.g3:1535:8: (c= conditionalDirAndBindingDecls )? (m= memberModifiers[func] )? key= FUNCTION ( ( SET | GET ) )? (I= IDENTIFIER | nq= notQuiteReservedWord ) formalParameterList[func] (C= COLON t= type )? body= functionBody
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              func=new FunctionRecord();
                      if (store)
                      {
                      	setCurrentFunction(func);
                      	{flushMetatags(func);}
                      }
                     
            }
            // ASCollector.g3:1542:9: (c= conditionalDirAndBindingDecls )?
            int alt69=2;
            switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA69_1 = input.LA(2);

                    if ( (LA69_1==XML_NS_OP) ) {
                        alt69=1;
                    }
                    }
                    break;
                case NATIVE:
                case DYNAMIC:
                case FINAL:
                case OVERRIDE:
                case STATIC:
                    {
                    int LA69_2 = input.LA(2);

                    if ( (LA69_2==XML_NS_OP) ) {
                        alt69=1;
                    }
                    }
                    break;
                case TO:
                case EACH:
                case GET:
                case SET:
                case NAMESPACE:
                    {
                    alt69=1;
                    }
                    break;
            }

            switch (alt69) {
                case 1 :
                    // ASCollector.g3:1542:10: c= conditionalDirAndBindingDecls
                    {
                    pushFollow(FOLLOW_conditionalDirAndBindingDecls_in_functionDeclaration7456);
                    c=conditionalDirAndBindingDecls();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, c.getTree());
                    if ( state.backtracking==0 ) {
                      func.captureStartPos(c);
                    }

                    }
                    break;

            }

            // ASCollector.g3:1545:5: (m= memberModifiers[func] )?
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( (LA70_0==INTERNAL||LA70_0==NATIVE||(LA70_0>=PRIVATE && LA70_0<=PUBLIC)||(LA70_0>=DYNAMIC && LA70_0<=STATIC)||LA70_0==IDENTIFIER) ) {
                alt70=1;
            }
            switch (alt70) {
                case 1 :
                    // ASCollector.g3:1545:6: m= memberModifiers[func]
                    {
                    pushFollow(FOLLOW_memberModifiers_in_functionDeclaration7494);
                    m=memberModifiers(func);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, m.getTree());
                    if ( state.backtracking==0 ) {
                      func.captureStartPos(m);
                    }

                    }
                    break;

            }

            key=(Token)match(input,FUNCTION,FOLLOW_FUNCTION_in_functionDeclaration7525); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            key_tree = (Object)adaptor.create(key);
            adaptor.addChild(root_0, key_tree);
            }
            if ( state.backtracking==0 ) {

                  	func.captureStartPos(key);
                  	if (c!=null)
                  		captureHiddenTokens(func, c);
                  	else if (m!=null)
                  		captureHiddenTokens(func, m);
                  	else
                  		captureHiddenTokens(func, key);
                  
            }
            // ASCollector.g3:1560:5: ( ( SET | GET ) )?
            int alt72=2;
            int LA72_0 = input.LA(1);

            if ( (LA72_0==SET) ) {
                int LA72_1 = input.LA(2);

                if ( (LA72_1==NATIVE||LA72_1==TO||(LA72_1>=EACH && LA72_1<=NAMESPACE)||(LA72_1>=DYNAMIC && LA72_1<=STATIC)||LA72_1==IDENTIFIER) ) {
                    alt72=1;
                }
            }
            else if ( (LA72_0==GET) ) {
                int LA72_2 = input.LA(2);

                if ( (LA72_2==NATIVE||LA72_2==TO||(LA72_2>=EACH && LA72_2<=NAMESPACE)||(LA72_2>=DYNAMIC && LA72_2<=STATIC)||LA72_2==IDENTIFIER) ) {
                    alt72=1;
                }
            }
            switch (alt72) {
                case 1 :
                    // ASCollector.g3:1561:6: ( SET | GET )
                    {
                    // ASCollector.g3:1561:6: ( SET | GET )
                    int alt71=2;
                    int LA71_0 = input.LA(1);

                    if ( (LA71_0==SET) ) {
                        alt71=1;
                    }
                    else if ( (LA71_0==GET) ) {
                        alt71=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 71, 0, input);

                        throw nvae;
                    }
                    switch (alt71) {
                        case 1 :
                            // ASCollector.g3:1561:7: SET
                            {
                            SET110=(Token)match(input,SET,FOLLOW_SET_in_functionDeclaration7553); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            SET110_tree = (Object)adaptor.create(SET110);
                            adaptor.addChild(root_0, SET110_tree);
                            }
                            if ( state.backtracking==0 ) {
                              func.setType(FunctionRecord.Type_Setter);
                            }

                            }
                            break;
                        case 2 :
                            // ASCollector.g3:1562:8: GET
                            {
                            GET111=(Token)match(input,GET,FOLLOW_GET_in_functionDeclaration7564); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            GET111_tree = (Object)adaptor.create(GET111);
                            adaptor.addChild(root_0, GET111_tree);
                            }
                            if ( state.backtracking==0 ) {
                              func.setType(FunctionRecord.Type_Getter);
                            }

                            }
                            break;

                    }


                    }
                    break;

            }

            // ASCollector.g3:1565:5: (I= IDENTIFIER | nq= notQuiteReservedWord )
            int alt73=2;
            int LA73_0 = input.LA(1);

            if ( (LA73_0==IDENTIFIER) ) {
                alt73=1;
            }
            else if ( (LA73_0==NATIVE||LA73_0==TO||(LA73_0>=EACH && LA73_0<=NAMESPACE)||(LA73_0>=DYNAMIC && LA73_0<=STATIC)) ) {
                alt73=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 73, 0, input);

                throw nvae;
            }
            switch (alt73) {
                case 1 :
                    // ASCollector.g3:1565:9: I= IDENTIFIER
                    {
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_functionDeclaration7593); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }
                    if ( state.backtracking==0 ) {
                      func.setName(I);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1566:9: nq= notQuiteReservedWord
                    {
                    pushFollow(FOLLOW_notQuiteReservedWord_in_functionDeclaration7607);
                    nq=notQuiteReservedWord();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nq.getTree());
                    if ( state.backtracking==0 ) {
                      func.setName(nq);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_formalParameterList_in_functionDeclaration7623);
            formalParameterList112=formalParameterList(func);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, formalParameterList112.getTree());
            // ASCollector.g3:1569:5: (C= COLON t= type )?
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( (LA74_0==COLON) ) {
                alt74=1;
            }
            switch (alt74) {
                case 1 :
                    // ASCollector.g3:1569:6: C= COLON t= type
                    {
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_functionDeclaration7634); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_type_in_functionDeclaration7639);
                    t=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree());
                    if ( state.backtracking==0 ) {
                      func.setReturnType(t);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_functionBody_in_functionDeclaration7653);
            body=functionBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, body.getTree());
            if ( state.backtracking==0 ) {

                   	func.captureEndPos(body);
                   	capturePostHiddenTokens(func, body);
                  	if (store)
                  	{
                  		if (getClassRecord()!=null)
                  		{
                  			getClassRecord().addFunctionRecord(func);
                  		}
                  		else
                  		{
                  			getCollector().addFunctionRecord(func);
                  		}
                  		setCurrentFunction(null);
                  	}
                  
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 51, functionDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "functionDeclaration"

    public static class functionExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "functionExpression"
    // ASCollector.g3:1589:1: functionExpression : F= FUNCTION (I= IDENTIFIER )? formalParameterList[null] (C= COLON type )? functionBody ;
    public final ASCollectorParser.functionExpression_return functionExpression() throws RecognitionException {
        ASCollectorParser.functionExpression_return retval = new ASCollectorParser.functionExpression_return();
        retval.start = input.LT(1);
        int functionExpression_StartIndex = input.index();
        Object root_0 = null;

        Token F=null;
        Token I=null;
        Token C=null;
        ASCollectorParser.formalParameterList_return formalParameterList113 = null;

        ASCollectorParser.type_return type114 = null;

        ASCollectorParser.functionBody_return functionBody115 = null;


        Object F_tree=null;
        Object I_tree=null;
        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return retval; }
            // ASCollector.g3:1592:5: (F= FUNCTION (I= IDENTIFIER )? formalParameterList[null] (C= COLON type )? functionBody )
            // ASCollector.g3:1592:9: F= FUNCTION (I= IDENTIFIER )? formalParameterList[null] (C= COLON type )? functionBody
            {
            root_0 = (Object)adaptor.nil();

            F=(Token)match(input,FUNCTION,FOLLOW_FUNCTION_in_functionExpression7686); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            F_tree = (Object)adaptor.create(F);
            adaptor.addChild(root_0, F_tree);
            }
            // ASCollector.g3:1592:21: (I= IDENTIFIER )?
            int alt75=2;
            int LA75_0 = input.LA(1);

            if ( (LA75_0==IDENTIFIER) ) {
                alt75=1;
            }
            switch (alt75) {
                case 1 :
                    // ASCollector.g3:1592:22: I= IDENTIFIER
                    {
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_functionExpression7692); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_formalParameterList_in_functionExpression7696);
            formalParameterList113=formalParameterList(null);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, formalParameterList113.getTree());
            // ASCollector.g3:1592:63: (C= COLON type )?
            int alt76=2;
            int LA76_0 = input.LA(1);

            if ( (LA76_0==COLON) ) {
                alt76=1;
            }
            switch (alt76) {
                case 1 :
                    // ASCollector.g3:1592:64: C= COLON type
                    {
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_functionExpression7702); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_type_in_functionExpression7705);
                    type114=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type114.getTree());

                    }
                    break;

            }

            pushFollow(FOLLOW_functionBody_in_functionExpression7710);
            functionBody115=functionBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, functionBody115.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 52, functionExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "functionExpression"

    public static class formalParameterList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "formalParameterList"
    // ASCollector.g3:1596:1: formalParameterList[DeclHolder holder] : L= LPAREN ( ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )? ) | formalEllipsisParameter[holder] )? R= RPAREN ;
    public final ASCollectorParser.formalParameterList_return formalParameterList(DeclHolder holder) throws RecognitionException {
        ASCollectorParser.formalParameterList_return retval = new ASCollectorParser.formalParameterList_return();
        retval.start = input.LT(1);
        int formalParameterList_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token C=null;
        Token R=null;
        ASCollectorParser.variableDeclaration_return variableDeclaration116 = null;

        ASCollectorParser.variableDeclaration_return variableDeclaration117 = null;

        ASCollectorParser.formalEllipsisParameter_return formalEllipsisParameter118 = null;

        ASCollectorParser.formalEllipsisParameter_return formalEllipsisParameter119 = null;


        Object L_tree=null;
        Object C_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return retval; }
            // ASCollector.g3:1597:5: (L= LPAREN ( ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )? ) | formalEllipsisParameter[holder] )? R= RPAREN )
            // ASCollector.g3:1599:6: L= LPAREN ( ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )? ) | formalEllipsisParameter[holder] )? R= RPAREN
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_formalParameterList7747); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:1600:9: ( ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )? ) | formalEllipsisParameter[holder] )?
            int alt79=3;
            int LA79_0 = input.LA(1);

            if ( (LA79_0==NATIVE||LA79_0==TO||(LA79_0>=EACH && LA79_0<=NAMESPACE)||(LA79_0>=DYNAMIC && LA79_0<=STATIC)||LA79_0==IDENTIFIER) ) {
                alt79=1;
            }
            else if ( (LA79_0==ELLIPSIS) ) {
                alt79=2;
            }
            switch (alt79) {
                case 1 :
                    // ASCollector.g3:1600:11: ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )? )
                    {
                    // ASCollector.g3:1600:11: ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )? )
                    // ASCollector.g3:1600:14: variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* (C= COMMA formalEllipsisParameter[holder] )?
                    {
                    pushFollow(FOLLOW_variableDeclaration_in_formalParameterList7764);
                    variableDeclaration116=variableDeclaration(holder);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclaration116.getTree());
                    // ASCollector.g3:1601:13: (C= COMMA variableDeclaration[holder] )*
                    loop77:
                    do {
                        int alt77=2;
                        int LA77_0 = input.LA(1);

                        if ( (LA77_0==COMMA) ) {
                            int LA77_1 = input.LA(2);

                            if ( (LA77_1==NATIVE||LA77_1==TO||(LA77_1>=EACH && LA77_1<=NAMESPACE)||(LA77_1>=DYNAMIC && LA77_1<=STATIC)||LA77_1==IDENTIFIER) ) {
                                alt77=1;
                            }


                        }


                        switch (alt77) {
                    	case 1 :
                    	    // ASCollector.g3:1602:16: C= COMMA variableDeclaration[holder]
                    	    {
                    	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_formalParameterList7800); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    C_tree = (Object)adaptor.create(C);
                    	    adaptor.addChild(root_0, C_tree);
                    	    }
                    	    pushFollow(FOLLOW_variableDeclaration_in_formalParameterList7834);
                    	    variableDeclaration117=variableDeclaration(holder);

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclaration117.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop77;
                        }
                    } while (true);

                    // ASCollector.g3:1606:13: (C= COMMA formalEllipsisParameter[holder] )?
                    int alt78=2;
                    int LA78_0 = input.LA(1);

                    if ( (LA78_0==COMMA) ) {
                        alt78=1;
                    }
                    switch (alt78) {
                        case 1 :
                            // ASCollector.g3:1606:16: C= COMMA formalEllipsisParameter[holder]
                            {
                            C=(Token)match(input,COMMA,FOLLOW_COMMA_in_formalParameterList7871); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            C_tree = (Object)adaptor.create(C);
                            adaptor.addChild(root_0, C_tree);
                            }
                            pushFollow(FOLLOW_formalEllipsisParameter_in_formalParameterList7875);
                            formalEllipsisParameter118=formalEllipsisParameter(holder);

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, formalEllipsisParameter118.getTree());

                            }
                            break;

                    }


                    }


                    }
                    break;
                case 2 :
                    // ASCollector.g3:1608:15: formalEllipsisParameter[holder]
                    {
                    pushFollow(FOLLOW_formalEllipsisParameter_in_formalParameterList7907);
                    formalEllipsisParameter119=formalEllipsisParameter(holder);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, formalEllipsisParameter119.getTree());

                    }
                    break;

            }

            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_formalParameterList7932); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 53, formalParameterList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "formalParameterList"

    public static class formalEllipsisParameter_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "formalEllipsisParameter"
    // ASCollector.g3:1615:1: formalEllipsisParameter[DeclHolder holder] : E= ELLIPSIS variableIdentifierDecl[holder] ;
    public final ASCollectorParser.formalEllipsisParameter_return formalEllipsisParameter(DeclHolder holder) throws RecognitionException {
        ASCollectorParser.formalEllipsisParameter_return retval = new ASCollectorParser.formalEllipsisParameter_return();
        retval.start = input.LT(1);
        int formalEllipsisParameter_StartIndex = input.index();
        Object root_0 = null;

        Token E=null;
        ASCollectorParser.variableIdentifierDecl_return variableIdentifierDecl120 = null;


        Object E_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return retval; }
            // ASCollector.g3:1616:5: (E= ELLIPSIS variableIdentifierDecl[holder] )
            // ASCollector.g3:1616:9: E= ELLIPSIS variableIdentifierDecl[holder]
            {
            root_0 = (Object)adaptor.nil();

            E=(Token)match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_formalEllipsisParameter7978); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            E_tree = (Object)adaptor.create(E);
            adaptor.addChild(root_0, E_tree);
            }
            pushFollow(FOLLOW_variableIdentifierDecl_in_formalEllipsisParameter7982);
            variableIdentifierDecl120=variableIdentifierDecl(holder);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableIdentifierDecl120.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 54, formalEllipsisParameter_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "formalEllipsisParameter"

    public static class functionBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "functionBody"
    // ASCollector.g3:1619:1: functionBody : L= LCURLY ( statement | functionDeclaration[false] )* R= RCURLY ;
    public final ASCollectorParser.functionBody_return functionBody() throws RecognitionException {
        ASCollectorParser.functionBody_return retval = new ASCollectorParser.functionBody_return();
        retval.start = input.LT(1);
        int functionBody_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.statement_return statement121 = null;

        ASCollectorParser.functionDeclaration_return functionDeclaration122 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return retval; }
            // ASCollector.g3:1620:5: (L= LCURLY ( statement | functionDeclaration[false] )* R= RCURLY )
            // ASCollector.g3:1620:9: L= LCURLY ( statement | functionDeclaration[false] )* R= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_functionBody8007); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:1622:7: ( statement | functionDeclaration[false] )*
            loop80:
            do {
                int alt80=3;
                alt80 = dfa80.predict(input);
                switch (alt80) {
            	case 1 :
            	    // ASCollector.g3:1622:8: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_functionBody8024);
            	    statement121=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement121.getTree());

            	    }
            	    break;
            	case 2 :
            	    // ASCollector.g3:1622:18: functionDeclaration[false]
            	    {
            	    pushFollow(FOLLOW_functionDeclaration_in_functionBody8026);
            	    functionDeclaration122=functionDeclaration(false);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, functionDeclaration122.getTree());

            	    }
            	    break;

            	default :
            	    break loop80;
                }
            } while (true);

            R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_functionBody8040); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 55, functionBody_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "functionBody"

    public static class memberModifiers_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "memberModifiers"
    // ASCollector.g3:1630:1: memberModifiers[TopLevelItemRecord rec] : ( memberModifier[rec] )+ ;
    public final ASCollectorParser.memberModifiers_return memberModifiers(TopLevelItemRecord rec) throws RecognitionException {
        ASCollectorParser.memberModifiers_return retval = new ASCollectorParser.memberModifiers_return();
        retval.start = input.LT(1);
        int memberModifiers_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.memberModifier_return memberModifier123 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return retval; }
            // ASCollector.g3:1631:5: ( ( memberModifier[rec] )+ )
            // ASCollector.g3:1633:5: ( memberModifier[rec] )+
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1633:5: ( memberModifier[rec] )+
            int cnt81=0;
            loop81:
            do {
                int alt81=2;
                int LA81_0 = input.LA(1);

                if ( (LA81_0==IDENTIFIER) ) {
                    int LA81_2 = input.LA(2);

                    if ( (synpred170_ASCollector()) ) {
                        alt81=1;
                    }


                }
                else if ( (LA81_0==INTERNAL||LA81_0==NATIVE||(LA81_0>=PRIVATE && LA81_0<=PUBLIC)||(LA81_0>=DYNAMIC && LA81_0<=STATIC)) ) {
                    alt81=1;
                }


                switch (alt81) {
            	case 1 :
            	    // ASCollector.g3:1633:6: memberModifier[rec]
            	    {
            	    pushFollow(FOLLOW_memberModifier_in_memberModifiers8072);
            	    memberModifier123=memberModifier(rec);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, memberModifier123.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt81 >= 1 ) break loop81;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(81, input);
                        throw eee;
                }
                cnt81++;
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 56, memberModifiers_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "memberModifiers"

    public static class memberModifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "memberModifier"
    // ASCollector.g3:1637:1: memberModifier[TopLevelItemRecord rec] : x= ( DYNAMIC | FINAL | INTERNAL | NATIVE | OVERRIDE | PRIVATE | PROTECTED | PUBLIC | STATIC | IDENTIFIER ) ;
    public final ASCollectorParser.memberModifier_return memberModifier(TopLevelItemRecord rec) throws RecognitionException {
        ASCollectorParser.memberModifier_return retval = new ASCollectorParser.memberModifier_return();
        retval.start = input.LT(1);
        int memberModifier_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;

        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return retval; }
            // ASCollector.g3:1638:5: (x= ( DYNAMIC | FINAL | INTERNAL | NATIVE | OVERRIDE | PRIVATE | PROTECTED | PUBLIC | STATIC | IDENTIFIER ) )
            // ASCollector.g3:1638:9: x= ( DYNAMIC | FINAL | INTERNAL | NATIVE | OVERRIDE | PRIVATE | PROTECTED | PUBLIC | STATIC | IDENTIFIER )
            {
            root_0 = (Object)adaptor.nil();

            x=(Token)input.LT(1);
            if ( input.LA(1)==INTERNAL||input.LA(1)==NATIVE||(input.LA(1)>=PRIVATE && input.LA(1)<=PUBLIC)||(input.LA(1)>=DYNAMIC && input.LA(1)<=STATIC)||input.LA(1)==IDENTIFIER ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(x));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }

            if ( state.backtracking==0 ) {

                  	if (rec!=null)
                  	{
                  		TextItem newItem=rec.addModifier(x);
                  		captureHiddenTokens(newItem, x);
                  		newItem.trimLeadingWhitespaceTokens();
                  	}
                  	
                  
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 57, memberModifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "memberModifier"

    public static class statement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // ASCollector.g3:1669:1: statement : ( blockStatement | directive | namespaceDirective[null] | constantVarStatement[null] | tryStatement | switchStatement | withStatement | returnStatement | breakStatement | continueStatement | forStatement | forInStatement | forEachInStatement | doWhileStatement | whileStatement | ifStatement | variableStatement[null] | throwStatement | labelledStatement | expression semic | emptyStatement ) ;
    public final ASCollectorParser.statement_return statement() throws RecognitionException {
        ASCollectorParser.statement_return retval = new ASCollectorParser.statement_return();
        retval.start = input.LT(1);
        int statement_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.blockStatement_return blockStatement124 = null;

        ASCollectorParser.directive_return directive125 = null;

        ASCollectorParser.namespaceDirective_return namespaceDirective126 = null;

        ASCollectorParser.constantVarStatement_return constantVarStatement127 = null;

        ASCollectorParser.tryStatement_return tryStatement128 = null;

        ASCollectorParser.switchStatement_return switchStatement129 = null;

        ASCollectorParser.withStatement_return withStatement130 = null;

        ASCollectorParser.returnStatement_return returnStatement131 = null;

        ASCollectorParser.breakStatement_return breakStatement132 = null;

        ASCollectorParser.continueStatement_return continueStatement133 = null;

        ASCollectorParser.forStatement_return forStatement134 = null;

        ASCollectorParser.forInStatement_return forInStatement135 = null;

        ASCollectorParser.forEachInStatement_return forEachInStatement136 = null;

        ASCollectorParser.doWhileStatement_return doWhileStatement137 = null;

        ASCollectorParser.whileStatement_return whileStatement138 = null;

        ASCollectorParser.ifStatement_return ifStatement139 = null;

        ASCollectorParser.variableStatement_return variableStatement140 = null;

        ASCollectorParser.throwStatement_return throwStatement141 = null;

        ASCollectorParser.labelledStatement_return labelledStatement142 = null;

        ASCollectorParser.expression_return expression143 = null;

        ASCollectorParser.semic_return semic144 = null;

        ASCollectorParser.emptyStatement_return emptyStatement145 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return retval; }
            // ASCollector.g3:1670:5: ( ( blockStatement | directive | namespaceDirective[null] | constantVarStatement[null] | tryStatement | switchStatement | withStatement | returnStatement | breakStatement | continueStatement | forStatement | forInStatement | forEachInStatement | doWhileStatement | whileStatement | ifStatement | variableStatement[null] | throwStatement | labelledStatement | expression semic | emptyStatement ) )
            // ASCollector.g3:1671:5: ( blockStatement | directive | namespaceDirective[null] | constantVarStatement[null] | tryStatement | switchStatement | withStatement | returnStatement | breakStatement | continueStatement | forStatement | forInStatement | forEachInStatement | doWhileStatement | whileStatement | ifStatement | variableStatement[null] | throwStatement | labelledStatement | expression semic | emptyStatement )
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              mStatementDepth++;
            }
            // ASCollector.g3:1672:5: ( blockStatement | directive | namespaceDirective[null] | constantVarStatement[null] | tryStatement | switchStatement | withStatement | returnStatement | breakStatement | continueStatement | forStatement | forInStatement | forEachInStatement | doWhileStatement | whileStatement | ifStatement | variableStatement[null] | throwStatement | labelledStatement | expression semic | emptyStatement )
            int alt82=21;
            alt82 = dfa82.predict(input);
            switch (alt82) {
                case 1 :
                    // ASCollector.g3:1672:7: blockStatement
                    {
                    pushFollow(FOLLOW_blockStatement_in_statement8253);
                    blockStatement124=blockStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, blockStatement124.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1673:9: directive
                    {
                    pushFollow(FOLLOW_directive_in_statement8263);
                    directive125=directive();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, directive125.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:1674:9: namespaceDirective[null]
                    {
                    pushFollow(FOLLOW_namespaceDirective_in_statement8273);
                    namespaceDirective126=namespaceDirective(null);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, namespaceDirective126.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:1675:10: constantVarStatement[null]
                    {
                    pushFollow(FOLLOW_constantVarStatement_in_statement8285);
                    constantVarStatement127=constantVarStatement(null);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, constantVarStatement127.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:1676:9: tryStatement
                    {
                    pushFollow(FOLLOW_tryStatement_in_statement8297);
                    tryStatement128=tryStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, tryStatement128.getTree());

                    }
                    break;
                case 6 :
                    // ASCollector.g3:1677:9: switchStatement
                    {
                    pushFollow(FOLLOW_switchStatement_in_statement8307);
                    switchStatement129=switchStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, switchStatement129.getTree());

                    }
                    break;
                case 7 :
                    // ASCollector.g3:1678:9: withStatement
                    {
                    pushFollow(FOLLOW_withStatement_in_statement8317);
                    withStatement130=withStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, withStatement130.getTree());

                    }
                    break;
                case 8 :
                    // ASCollector.g3:1679:11: returnStatement
                    {
                    pushFollow(FOLLOW_returnStatement_in_statement8329);
                    returnStatement131=returnStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, returnStatement131.getTree());

                    }
                    break;
                case 9 :
                    // ASCollector.g3:1680:11: breakStatement
                    {
                    pushFollow(FOLLOW_breakStatement_in_statement8342);
                    breakStatement132=breakStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, breakStatement132.getTree());

                    }
                    break;
                case 10 :
                    // ASCollector.g3:1681:11: continueStatement
                    {
                    pushFollow(FOLLOW_continueStatement_in_statement8355);
                    continueStatement133=continueStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, continueStatement133.getTree());

                    }
                    break;
                case 11 :
                    // ASCollector.g3:1682:9: forStatement
                    {
                    pushFollow(FOLLOW_forStatement_in_statement8366);
                    forStatement134=forStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forStatement134.getTree());

                    }
                    break;
                case 12 :
                    // ASCollector.g3:1683:9: forInStatement
                    {
                    pushFollow(FOLLOW_forInStatement_in_statement8376);
                    forInStatement135=forInStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forInStatement135.getTree());

                    }
                    break;
                case 13 :
                    // ASCollector.g3:1684:9: forEachInStatement
                    {
                    pushFollow(FOLLOW_forEachInStatement_in_statement8386);
                    forEachInStatement136=forEachInStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forEachInStatement136.getTree());

                    }
                    break;
                case 14 :
                    // ASCollector.g3:1685:9: doWhileStatement
                    {
                    pushFollow(FOLLOW_doWhileStatement_in_statement8396);
                    doWhileStatement137=doWhileStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, doWhileStatement137.getTree());

                    }
                    break;
                case 15 :
                    // ASCollector.g3:1686:9: whileStatement
                    {
                    pushFollow(FOLLOW_whileStatement_in_statement8406);
                    whileStatement138=whileStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, whileStatement138.getTree());

                    }
                    break;
                case 16 :
                    // ASCollector.g3:1687:9: ifStatement
                    {
                    pushFollow(FOLLOW_ifStatement_in_statement8416);
                    ifStatement139=ifStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, ifStatement139.getTree());

                    }
                    break;
                case 17 :
                    // ASCollector.g3:1688:11: variableStatement[null]
                    {
                    pushFollow(FOLLOW_variableStatement_in_statement8428);
                    variableStatement140=variableStatement(null);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableStatement140.getTree());

                    }
                    break;
                case 18 :
                    // ASCollector.g3:1689:11: throwStatement
                    {
                    pushFollow(FOLLOW_throwStatement_in_statement8442);
                    throwStatement141=throwStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, throwStatement141.getTree());

                    }
                    break;
                case 19 :
                    // ASCollector.g3:1690:9: labelledStatement
                    {
                    pushFollow(FOLLOW_labelledStatement_in_statement8453);
                    labelledStatement142=labelledStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, labelledStatement142.getTree());

                    }
                    break;
                case 20 :
                    // ASCollector.g3:1691:10: expression semic
                    {
                    pushFollow(FOLLOW_expression_in_statement8465);
                    expression143=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression143.getTree());
                    pushFollow(FOLLOW_semic_in_statement8467);
                    semic144=semic();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, semic144.getTree());

                    }
                    break;
                case 21 :
                    // ASCollector.g3:1692:9: emptyStatement
                    {
                    pushFollow(FOLLOW_emptyStatement_in_statement8478);
                    emptyStatement145=emptyStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, emptyStatement145.getTree());

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
              mStatementDepth--;
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 58, statement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class blockStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "blockStatement"
    // ASCollector.g3:1702:1: blockStatement : (c= conditionalCompilerOption )? L= LCURLY ( statement )* R= RCURLY ;
    public final ASCollectorParser.blockStatement_return blockStatement() throws RecognitionException {
        ASCollectorParser.blockStatement_return retval = new ASCollectorParser.blockStatement_return();
        retval.start = input.LT(1);
        int blockStatement_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.conditionalCompilerOption_return c = null;

        ASCollectorParser.statement_return statement146 = null;


        Object L_tree=null;
        Object R_tree=null;


        	StaticInitializerRecord item=null;
        	boolean freestandingBlock=false;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return retval; }
            // ASCollector.g3:1707:5: ( (c= conditionalCompilerOption )? L= LCURLY ( statement )* R= RCURLY )
            // ASCollector.g3:1707:9: (c= conditionalCompilerOption )? L= LCURLY ( statement )* R= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              item=new StaticInitializerRecord();
            }
            // ASCollector.g3:1709:6: (c= conditionalCompilerOption )?
            int alt83=2;
            int LA83_0 = input.LA(1);

            if ( (LA83_0==NATIVE||LA83_0==TO||(LA83_0>=EACH && LA83_0<=NAMESPACE)||(LA83_0>=DYNAMIC && LA83_0<=STATIC)||LA83_0==IDENTIFIER) ) {
                alt83=1;
            }
            switch (alt83) {
                case 1 :
                    // ASCollector.g3:1709:7: c= conditionalCompilerOption
                    {
                    pushFollow(FOLLOW_conditionalCompilerOption_in_blockStatement8531);
                    c=conditionalCompilerOption();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, c.getTree());

                    }
                    break;

            }

            L=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_blockStatement8537); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            if ( state.backtracking==0 ) {
              freestandingBlock=getFunctionRecord()==null && getClassRecord()!=null && mStatementDepth==1;
            }
            // ASCollector.g3:1711:6: ( statement )*
            loop84:
            do {
                int alt84=2;
                int LA84_0 = input.LA(1);

                if ( ((LA84_0>=AS && LA84_0<=LCURLY)||LA84_0==LPAREN||LA84_0==LBRACK||LA84_0==LT||(LA84_0>=PLUS && LA84_0<=STAR)||(LA84_0>=INC && LA84_0<=DEC)||(LA84_0>=NOT && LA84_0<=INV)||(LA84_0>=XML_AT && LA84_0<=XML_LS_STD)||(LA84_0>=SINGLE_QUOTE_LITERAL && LA84_0<=DOUBLE_QUOTE_LITERAL)||LA84_0==REGULAR_EXPR_LITERAL||LA84_0==HEX_NUMBER_LITERAL||LA84_0==DEC_NUMBER_LITERAL||LA84_0==IDENTIFIER||(LA84_0>=XML_COMMENT && LA84_0<=XML_PI)) ) {
                    alt84=1;
                }


                switch (alt84) {
            	case 1 :
            	    // ASCollector.g3:0:0: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_blockStatement8553);
            	    statement146=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement146.getTree());

            	    }
            	    break;

            	default :
            	    break loop84;
                }
            } while (true);

            R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_blockStatement8565); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            if ( state.backtracking==0 ) {

                  		if (freestandingBlock)
                  		{
                  			if (c!=null)
                  			{
              					item.captureStartPos(c);
              			 		captureHiddenTokens(item, c);
              				}
                  		
                  			item.captureStartPos(L);
                  			item.captureEndPos(R);
                 				//this is a static initializer, so add it to the list of static initializers
                 				getClassRecord().addStaticInitializer(item);
                  		}
                  		
                  	
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 59, blockStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "blockStatement"

    public static class throwStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "throwStatement"
    // ASCollector.g3:1734:1: throwStatement : T= THROW e= expression semic ;
    public final ASCollectorParser.throwStatement_return throwStatement() throws RecognitionException {
        ASCollectorParser.throwStatement_return retval = new ASCollectorParser.throwStatement_return();
        retval.start = input.LT(1);
        int throwStatement_StartIndex = input.index();
        Object root_0 = null;

        Token T=null;
        ASCollectorParser.expression_return e = null;

        ASCollectorParser.semic_return semic147 = null;


        Object T_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return retval; }
            // ASCollector.g3:1735:2: (T= THROW e= expression semic )
            // ASCollector.g3:1735:5: T= THROW e= expression semic
            {
            root_0 = (Object)adaptor.nil();

            T=(Token)match(input,THROW,FOLLOW_THROW_in_throwStatement8597); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            T_tree = (Object)adaptor.create(T);
            adaptor.addChild(root_0, T_tree);
            }
            pushFollow(FOLLOW_expression_in_throwStatement8602);
            e=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, e.getTree());
            if ( state.backtracking==0 ) {

              			FunctionRecord rec=getFunctionRecord();
              			if (rec!=null)
              				rec.addThrowsExpression(e);
              		
            }
            pushFollow(FOLLOW_semic_in_throwStatement8610);
            semic147=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic147.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 60, throwStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "throwStatement"

    public static class constantVarStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "constantVarStatement"
    // ASCollector.g3:1746:1: constantVarStatement[PropertyLine rec] : C= CONST vdl= variableDeclarationList[rec] (S= SEMI )? ;
    public final ASCollectorParser.constantVarStatement_return constantVarStatement(PropertyLine rec) throws RecognitionException {
        ASCollectorParser.constantVarStatement_return retval = new ASCollectorParser.constantVarStatement_return();
        retval.start = input.LT(1);
        int constantVarStatement_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        Token S=null;
        ASCollectorParser.variableDeclarationList_return vdl = null;


        Object C_tree=null;
        Object S_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return retval; }
            // ASCollector.g3:1747:5: (C= CONST vdl= variableDeclarationList[rec] (S= SEMI )? )
            // ASCollector.g3:1747:9: C= CONST vdl= variableDeclarationList[rec] (S= SEMI )?
            {
            root_0 = (Object)adaptor.nil();

            C=(Token)match(input,CONST,FOLLOW_CONST_in_constantVarStatement8631); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            C_tree = (Object)adaptor.create(C);
            adaptor.addChild(root_0, C_tree);
            }
            if ( state.backtracking==0 ) {

                  	if (rec!=null)
                  	{
                  		rec.setConst(true);
                  	}
                  
            }
            pushFollow(FOLLOW_variableDeclarationList_in_constantVarStatement8652);
            vdl=variableDeclarationList(rec);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, vdl.getTree());
            // ASCollector.g3:1759:40: (S= SEMI )?
            int alt85=2;
            int LA85_0 = input.LA(1);

            if ( (LA85_0==SEMI) ) {
                int LA85_1 = input.LA(2);

                if ( (synpred202_ASCollector()) ) {
                    alt85=1;
                }
            }
            switch (alt85) {
                case 1 :
                    // ASCollector.g3:1759:41: S= SEMI
                    {
                    S=(Token)match(input,SEMI,FOLLOW_SEMI_in_constantVarStatement8658); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 61, constantVarStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "constantVarStatement"

    public static class useNamespaceDirective_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "useNamespaceDirective"
    // ASCollector.g3:1775:1: useNamespaceDirective : U= USE N= NAMESPACE q1= qualifiedIdentifier (C= COMMA q2= qualifiedIdentifier )* s= semic ;
    public final ASCollectorParser.useNamespaceDirective_return useNamespaceDirective() throws RecognitionException {
        ASCollectorParser.useNamespaceDirective_return retval = new ASCollectorParser.useNamespaceDirective_return();
        retval.start = input.LT(1);
        int useNamespaceDirective_StartIndex = input.index();
        Object root_0 = null;

        Token U=null;
        Token N=null;
        Token C=null;
        ASCollectorParser.qualifiedIdentifier_return q1 = null;

        ASCollectorParser.qualifiedIdentifier_return q2 = null;

        ASCollectorParser.semic_return s = null;


        Object U_tree=null;
        Object N_tree=null;
        Object C_tree=null;


        	UseNamespaceItem item=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return retval; }
            // ASCollector.g3:1779:2: (U= USE N= NAMESPACE q1= qualifiedIdentifier (C= COMMA q2= qualifiedIdentifier )* s= semic )
            // ASCollector.g3:1780:2: U= USE N= NAMESPACE q1= qualifiedIdentifier (C= COMMA q2= qualifiedIdentifier )* s= semic
            {
            root_0 = (Object)adaptor.nil();

            if ( state.backtracking==0 ) {
              item=new UseNamespaceItem();
            }
            U=(Token)match(input,USE,FOLLOW_USE_in_useNamespaceDirective8711); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            U_tree = (Object)adaptor.create(U);
            adaptor.addChild(root_0, U_tree);
            }
            if ( state.backtracking==0 ) {
              item.captureStartPos(U);captureHiddenTokens(item, U);
            }
            N=(Token)match(input,NAMESPACE,FOLLOW_NAMESPACE_in_useNamespaceDirective8719); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            N_tree = (Object)adaptor.create(N);
            adaptor.addChild(root_0, N_tree);
            }
            pushFollow(FOLLOW_qualifiedIdentifier_in_useNamespaceDirective8724);
            q1=qualifiedIdentifier();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, q1.getTree());
            if ( state.backtracking==0 ) {
              item.addNamespace(q1);
            }
            // ASCollector.g3:1785:2: (C= COMMA q2= qualifiedIdentifier )*
            loop86:
            do {
                int alt86=2;
                int LA86_0 = input.LA(1);

                if ( (LA86_0==COMMA) ) {
                    alt86=1;
                }


                switch (alt86) {
            	case 1 :
            	    // ASCollector.g3:1785:3: C= COMMA q2= qualifiedIdentifier
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_useNamespaceDirective8732); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_qualifiedIdentifier_in_useNamespaceDirective8737);
            	    q2=qualifiedIdentifier();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, q2.getTree());
            	    if ( state.backtracking==0 ) {
            	      item.addNamespace(q2);
            	    }

            	    }
            	    break;

            	default :
            	    break loop86;
                }
            } while (true);

            pushFollow(FOLLOW_semic_in_useNamespaceDirective8746);
            s=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());
            if ( state.backtracking==0 ) {

              		if (s!=null)
              		{
              			item.captureEndPos(s);
              			capturePostHiddenTokens(item, s);
              		}
              		else if (q2!=null)
              		{
              			item.captureEndPos(q2);
              			capturePostHiddenTokens(item, q2);
              		}
              		else
              		{
              			item.captureEndPos(q1);
              			capturePostHiddenTokens(item, q1);
              		}
              			
              		if (getFunctionRecord()!=null)
              		{
              			//don't keep if inside function
              		}
              		else if (getClassRecord()!=null)
              		{
              			getClassRecord().addUseNamespace(item);
              		}
              		else
              		{
              			getCollector().addUseNamespace(item);
              		}
              	
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 62, useNamespaceDirective_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "useNamespaceDirective"

    public static class namespaceDirective_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "namespaceDirective"
    // ASCollector.g3:1822:1: namespaceDirective[PropertyLine rec] : N= NAMESPACE q= qualifiedIdentifier (A= ASSIGN s= stringLiteral )? semic ;
    public final ASCollectorParser.namespaceDirective_return namespaceDirective(PropertyLine rec) throws RecognitionException {
        ASCollectorParser.namespaceDirective_return retval = new ASCollectorParser.namespaceDirective_return();
        retval.start = input.LT(1);
        int namespaceDirective_StartIndex = input.index();
        Object root_0 = null;

        Token N=null;
        Token A=null;
        ASCollectorParser.qualifiedIdentifier_return q = null;

        ASCollectorParser.stringLiteral_return s = null;

        ASCollectorParser.semic_return semic148 = null;


        Object N_tree=null;
        Object A_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return retval; }
            // ASCollector.g3:1823:5: (N= NAMESPACE q= qualifiedIdentifier (A= ASSIGN s= stringLiteral )? semic )
            // ASCollector.g3:1824:5: N= NAMESPACE q= qualifiedIdentifier (A= ASSIGN s= stringLiteral )? semic
            {
            root_0 = (Object)adaptor.nil();

            N=(Token)match(input,NAMESPACE,FOLLOW_NAMESPACE_in_namespaceDirective8778); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            N_tree = (Object)adaptor.create(N);
            adaptor.addChild(root_0, N_tree);
            }
            pushFollow(FOLLOW_qualifiedIdentifier_in_namespaceDirective8789);
            q=qualifiedIdentifier();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, q.getTree());
            // ASCollector.g3:1826:5: (A= ASSIGN s= stringLiteral )?
            int alt87=2;
            int LA87_0 = input.LA(1);

            if ( (LA87_0==ASSIGN) ) {
                alt87=1;
            }
            switch (alt87) {
                case 1 :
                    // ASCollector.g3:1826:7: A= ASSIGN s= stringLiteral
                    {
                    A=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_namespaceDirective8799); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    A_tree = (Object)adaptor.create(A);
                    adaptor.addChild(root_0, A_tree);
                    }
                    pushFollow(FOLLOW_stringLiteral_in_namespaceDirective8805);
                    s=stringLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_namespaceDirective8810);
            semic148=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic148.getTree());
            if ( state.backtracking==0 ) {

                  	if (rec!=null)
                  	{
              			DeclRecord decl=new DeclRecord(q, s);
              			rec.addDecl(decl);
              		}
                  
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 63, namespaceDirective_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "namespaceDirective"

    public static class tryStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "tryStatement"
    // ASCollector.g3:1841:1: tryStatement : T= TRY blockStatement ( ( catchClause )+ finallyClause | ( catchClause )+ | finallyClause ) ;
    public final ASCollectorParser.tryStatement_return tryStatement() throws RecognitionException {
        ASCollectorParser.tryStatement_return retval = new ASCollectorParser.tryStatement_return();
        retval.start = input.LT(1);
        int tryStatement_StartIndex = input.index();
        Object root_0 = null;

        Token T=null;
        ASCollectorParser.blockStatement_return blockStatement149 = null;

        ASCollectorParser.catchClause_return catchClause150 = null;

        ASCollectorParser.finallyClause_return finallyClause151 = null;

        ASCollectorParser.catchClause_return catchClause152 = null;

        ASCollectorParser.finallyClause_return finallyClause153 = null;


        Object T_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return retval; }
            // ASCollector.g3:1842:5: (T= TRY blockStatement ( ( catchClause )+ finallyClause | ( catchClause )+ | finallyClause ) )
            // ASCollector.g3:1842:8: T= TRY blockStatement ( ( catchClause )+ finallyClause | ( catchClause )+ | finallyClause )
            {
            root_0 = (Object)adaptor.nil();

            T=(Token)match(input,TRY,FOLLOW_TRY_in_tryStatement8842); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            T_tree = (Object)adaptor.create(T);
            adaptor.addChild(root_0, T_tree);
            }
            pushFollow(FOLLOW_blockStatement_in_tryStatement8846);
            blockStatement149=blockStatement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, blockStatement149.getTree());
            // ASCollector.g3:1843:9: ( ( catchClause )+ finallyClause | ( catchClause )+ | finallyClause )
            int alt90=3;
            int LA90_0 = input.LA(1);

            if ( (LA90_0==CATCH) ) {
                int LA90_1 = input.LA(2);

                if ( (synpred206_ASCollector()) ) {
                    alt90=1;
                }
                else if ( (synpred208_ASCollector()) ) {
                    alt90=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 90, 1, input);

                    throw nvae;
                }
            }
            else if ( (LA90_0==FINALLY) ) {
                alt90=3;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 90, 0, input);

                throw nvae;
            }
            switch (alt90) {
                case 1 :
                    // ASCollector.g3:1843:11: ( catchClause )+ finallyClause
                    {
                    // ASCollector.g3:1843:11: ( catchClause )+
                    int cnt88=0;
                    loop88:
                    do {
                        int alt88=2;
                        int LA88_0 = input.LA(1);

                        if ( (LA88_0==CATCH) ) {
                            alt88=1;
                        }


                        switch (alt88) {
                    	case 1 :
                    	    // ASCollector.g3:0:0: catchClause
                    	    {
                    	    pushFollow(FOLLOW_catchClause_in_tryStatement8859);
                    	    catchClause150=catchClause();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, catchClause150.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt88 >= 1 ) break loop88;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(88, input);
                                throw eee;
                        }
                        cnt88++;
                    } while (true);

                    pushFollow(FOLLOW_finallyClause_in_tryStatement8862);
                    finallyClause151=finallyClause();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, finallyClause151.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1844:11: ( catchClause )+
                    {
                    // ASCollector.g3:1844:11: ( catchClause )+
                    int cnt89=0;
                    loop89:
                    do {
                        int alt89=2;
                        int LA89_0 = input.LA(1);

                        if ( (LA89_0==CATCH) ) {
                            int LA89_2 = input.LA(2);

                            if ( (LA89_2==LPAREN) ) {
                                alt89=1;
                            }


                        }


                        switch (alt89) {
                    	case 1 :
                    	    // ASCollector.g3:0:0: catchClause
                    	    {
                    	    pushFollow(FOLLOW_catchClause_in_tryStatement8874);
                    	    catchClause152=catchClause();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, catchClause152.getTree());

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt89 >= 1 ) break loop89;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(89, input);
                                throw eee;
                        }
                        cnt89++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // ASCollector.g3:1845:11: finallyClause
                    {
                    pushFollow(FOLLOW_finallyClause_in_tryStatement8887);
                    finallyClause153=finallyClause();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, finallyClause153.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 64, tryStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "tryStatement"

    public static class catchClause_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "catchClause"
    // ASCollector.g3:1849:1: catchClause : C= CATCH L= LPAREN variableIdentifierDecl[null] R= RPAREN blockStatement ;
    public final ASCollectorParser.catchClause_return catchClause() throws RecognitionException {
        ASCollectorParser.catchClause_return retval = new ASCollectorParser.catchClause_return();
        retval.start = input.LT(1);
        int catchClause_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        Token L=null;
        Token R=null;
        ASCollectorParser.variableIdentifierDecl_return variableIdentifierDecl154 = null;

        ASCollectorParser.blockStatement_return blockStatement155 = null;


        Object C_tree=null;
        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return retval; }
            // ASCollector.g3:1850:5: (C= CATCH L= LPAREN variableIdentifierDecl[null] R= RPAREN blockStatement )
            // ASCollector.g3:1850:8: C= CATCH L= LPAREN variableIdentifierDecl[null] R= RPAREN blockStatement
            {
            root_0 = (Object)adaptor.nil();

            C=(Token)match(input,CATCH,FOLLOW_CATCH_in_catchClause8917); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            C_tree = (Object)adaptor.create(C);
            adaptor.addChild(root_0, C_tree);
            }
            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_catchClause8922); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_variableIdentifierDecl_in_catchClause8925);
            variableIdentifierDecl154=variableIdentifierDecl(null);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableIdentifierDecl154.getTree());
            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_catchClause8930); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            pushFollow(FOLLOW_blockStatement_in_catchClause8933);
            blockStatement155=blockStatement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, blockStatement155.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 65, catchClause_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "catchClause"

    public static class finallyClause_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "finallyClause"
    // ASCollector.g3:1853:1: finallyClause : F= FINALLY blockStatement ;
    public final ASCollectorParser.finallyClause_return finallyClause() throws RecognitionException {
        ASCollectorParser.finallyClause_return retval = new ASCollectorParser.finallyClause_return();
        retval.start = input.LT(1);
        int finallyClause_StartIndex = input.index();
        Object root_0 = null;

        Token F=null;
        ASCollectorParser.blockStatement_return blockStatement156 = null;


        Object F_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return retval; }
            // ASCollector.g3:1854:5: (F= FINALLY blockStatement )
            // ASCollector.g3:1854:8: F= FINALLY blockStatement
            {
            root_0 = (Object)adaptor.nil();

            F=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause8954); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            F_tree = (Object)adaptor.create(F);
            adaptor.addChild(root_0, F_tree);
            }
            pushFollow(FOLLOW_blockStatement_in_finallyClause8957);
            blockStatement156=blockStatement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, blockStatement156.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 66, finallyClause_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "finallyClause"

    public static class labelledStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "labelledStatement"
    // ASCollector.g3:1861:1: labelledStatement : I= IDENTIFIER C= COLON statement ;
    public final ASCollectorParser.labelledStatement_return labelledStatement() throws RecognitionException {
        ASCollectorParser.labelledStatement_return retval = new ASCollectorParser.labelledStatement_return();
        retval.start = input.LT(1);
        int labelledStatement_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        Token C=null;
        ASCollectorParser.statement_return statement157 = null;


        Object I_tree=null;
        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return retval; }
            // ASCollector.g3:1862:5: (I= IDENTIFIER C= COLON statement )
            // ASCollector.g3:1862:8: I= IDENTIFIER C= COLON statement
            {
            root_0 = (Object)adaptor.nil();

            I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_labelledStatement8982); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }
            C=(Token)match(input,COLON,FOLLOW_COLON_in_labelledStatement8993); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            C_tree = (Object)adaptor.create(C);
            adaptor.addChild(root_0, C_tree);
            }
            pushFollow(FOLLOW_statement_in_labelledStatement9008);
            statement157=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement157.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 67, labelledStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "labelledStatement"

    public static class switchStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "switchStatement"
    // ASCollector.g3:1873:1: switchStatement : S= SWITCH parExpression L= LCURLY ( switchBlockStatementGroup )* R= RCURLY ;
    public final ASCollectorParser.switchStatement_return switchStatement() throws RecognitionException {
        ASCollectorParser.switchStatement_return retval = new ASCollectorParser.switchStatement_return();
        retval.start = input.LT(1);
        int switchStatement_StartIndex = input.index();
        Object root_0 = null;

        Token S=null;
        Token L=null;
        Token R=null;
        ASCollectorParser.parExpression_return parExpression158 = null;

        ASCollectorParser.switchBlockStatementGroup_return switchBlockStatementGroup159 = null;


        Object S_tree=null;
        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return retval; }
            // ASCollector.g3:1874:5: (S= SWITCH parExpression L= LCURLY ( switchBlockStatementGroup )* R= RCURLY )
            // ASCollector.g3:1874:9: S= SWITCH parExpression L= LCURLY ( switchBlockStatementGroup )* R= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            S=(Token)match(input,SWITCH,FOLLOW_SWITCH_in_switchStatement9040); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            S_tree = (Object)adaptor.create(S);
            adaptor.addChild(root_0, S_tree);
            }
            pushFollow(FOLLOW_parExpression_in_switchStatement9043);
            parExpression158=parExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression158.getTree());
            L=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_switchStatement9054); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:1877:6: ( switchBlockStatementGroup )*
            loop91:
            do {
                int alt91=2;
                int LA91_0 = input.LA(1);

                if ( (LA91_0==CASE||LA91_0==DEFAULT) ) {
                    alt91=1;
                }


                switch (alt91) {
            	case 1 :
            	    // ASCollector.g3:0:0: switchBlockStatementGroup
            	    {
            	    pushFollow(FOLLOW_switchBlockStatementGroup_in_switchStatement9069);
            	    switchBlockStatementGroup159=switchBlockStatementGroup();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, switchBlockStatementGroup159.getTree());

            	    }
            	    break;

            	default :
            	    break loop91;
                }
            } while (true);

            R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_switchStatement9081); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 68, switchStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "switchStatement"

    public static class switchBlockStatementGroup_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "switchBlockStatementGroup"
    // ASCollector.g3:1885:1: switchBlockStatementGroup : switchLabel ( statement )* ( breakStatement )? ;
    public final ASCollectorParser.switchBlockStatementGroup_return switchBlockStatementGroup() throws RecognitionException {
        ASCollectorParser.switchBlockStatementGroup_return retval = new ASCollectorParser.switchBlockStatementGroup_return();
        retval.start = input.LT(1);
        int switchBlockStatementGroup_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.switchLabel_return switchLabel160 = null;

        ASCollectorParser.statement_return statement161 = null;

        ASCollectorParser.breakStatement_return breakStatement162 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return retval; }
            // ASCollector.g3:1886:5: ( switchLabel ( statement )* ( breakStatement )? )
            // ASCollector.g3:1886:10: switchLabel ( statement )* ( breakStatement )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup9112);
            switchLabel160=switchLabel();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, switchLabel160.getTree());
            // ASCollector.g3:1886:23: ( statement )*
            loop92:
            do {
                int alt92=2;
                alt92 = dfa92.predict(input);
                switch (alt92) {
            	case 1 :
            	    // ASCollector.g3:0:0: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_switchBlockStatementGroup9115);
            	    statement161=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement161.getTree());

            	    }
            	    break;

            	default :
            	    break loop92;
                }
            } while (true);

            // ASCollector.g3:1886:35: ( breakStatement )?
            int alt93=2;
            int LA93_0 = input.LA(1);

            if ( (LA93_0==BREAK) ) {
                alt93=1;
            }
            switch (alt93) {
                case 1 :
                    // ASCollector.g3:0:0: breakStatement
                    {
                    pushFollow(FOLLOW_breakStatement_in_switchBlockStatementGroup9119);
                    breakStatement162=breakStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, breakStatement162.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 69, switchBlockStatementGroup_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "switchBlockStatementGroup"

    public static class switchLabel_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "switchLabel"
    // ASCollector.g3:1889:1: switchLabel : (C= CASE expression C= COLON | D= DEFAULT C= COLON );
    public final ASCollectorParser.switchLabel_return switchLabel() throws RecognitionException {
        ASCollectorParser.switchLabel_return retval = new ASCollectorParser.switchLabel_return();
        retval.start = input.LT(1);
        int switchLabel_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        Token D=null;
        ASCollectorParser.expression_return expression163 = null;


        Object C_tree=null;
        Object D_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return retval; }
            // ASCollector.g3:1890:5: (C= CASE expression C= COLON | D= DEFAULT C= COLON )
            int alt94=2;
            int LA94_0 = input.LA(1);

            if ( (LA94_0==CASE) ) {
                alt94=1;
            }
            else if ( (LA94_0==DEFAULT) ) {
                alt94=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 94, 0, input);

                throw nvae;
            }
            switch (alt94) {
                case 1 :
                    // ASCollector.g3:1890:9: C= CASE expression C= COLON
                    {
                    root_0 = (Object)adaptor.nil();

                    C=(Token)match(input,CASE,FOLLOW_CASE_in_switchLabel9145); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_expression_in_switchLabel9148);
                    expression163=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression163.getTree());
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_switchLabel9152); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1892:9: D= DEFAULT C= COLON
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel9172); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_switchLabel9177); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 70, switchLabel_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "switchLabel"

    public static class withStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "withStatement"
    // ASCollector.g3:1900:1: withStatement : W= WITH L= LPAREN expression R= RPAREN statement ;
    public final ASCollectorParser.withStatement_return withStatement() throws RecognitionException {
        ASCollectorParser.withStatement_return retval = new ASCollectorParser.withStatement_return();
        retval.start = input.LT(1);
        int withStatement_StartIndex = input.index();
        Object root_0 = null;

        Token W=null;
        Token L=null;
        Token R=null;
        ASCollectorParser.expression_return expression164 = null;

        ASCollectorParser.statement_return statement165 = null;


        Object W_tree=null;
        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return retval; }
            // ASCollector.g3:1901:5: (W= WITH L= LPAREN expression R= RPAREN statement )
            // ASCollector.g3:1901:9: W= WITH L= LPAREN expression R= RPAREN statement
            {
            root_0 = (Object)adaptor.nil();

            W=(Token)match(input,WITH,FOLLOW_WITH_in_withStatement9210); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            W_tree = (Object)adaptor.create(W);
            adaptor.addChild(root_0, W_tree);
            }
            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_withStatement9216); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_expression_in_withStatement9220);
            expression164=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression164.getTree());
            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_withStatement9225); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            pushFollow(FOLLOW_statement_in_withStatement9230);
            statement165=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement165.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 71, withStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "withStatement"

    public static class returnStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "returnStatement"
    // ASCollector.g3:1908:1: returnStatement : R= RETURN ( expression )? semic ;
    public final ASCollectorParser.returnStatement_return returnStatement() throws RecognitionException {
        ASCollectorParser.returnStatement_return retval = new ASCollectorParser.returnStatement_return();
        retval.start = input.LT(1);
        int returnStatement_StartIndex = input.index();
        Object root_0 = null;

        Token R=null;
        ASCollectorParser.expression_return expression166 = null;

        ASCollectorParser.semic_return semic167 = null;


        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return retval; }
            // ASCollector.g3:1909:5: (R= RETURN ( expression )? semic )
            // ASCollector.g3:1909:9: R= RETURN ( expression )? semic
            {
            root_0 = (Object)adaptor.nil();

            R=(Token)match(input,RETURN,FOLLOW_RETURN_in_returnStatement9256); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            // ASCollector.g3:1909:19: ( expression )?
            int alt95=2;
            int LA95_0 = input.LA(1);

            if ( ((LA95_0>=AS && LA95_0<=STATIC)||LA95_0==LCURLY||LA95_0==LPAREN||LA95_0==LBRACK||LA95_0==LT||(LA95_0>=PLUS && LA95_0<=STAR)||(LA95_0>=INC && LA95_0<=DEC)||(LA95_0>=NOT && LA95_0<=INV)||(LA95_0>=XML_AT && LA95_0<=XML_LS_STD)||(LA95_0>=SINGLE_QUOTE_LITERAL && LA95_0<=DOUBLE_QUOTE_LITERAL)||LA95_0==REGULAR_EXPR_LITERAL||LA95_0==HEX_NUMBER_LITERAL||LA95_0==DEC_NUMBER_LITERAL||LA95_0==IDENTIFIER||(LA95_0>=XML_COMMENT && LA95_0<=XML_PI)) ) {
                alt95=1;
            }
            switch (alt95) {
                case 1 :
                    // ASCollector.g3:1909:22: expression
                    {
                    pushFollow(FOLLOW_expression_in_returnStatement9262);
                    expression166=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression166.getTree());

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_returnStatement9266);
            semic167=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic167.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 72, returnStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "returnStatement"

    public static class breakStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "breakStatement"
    // ASCollector.g3:1917:1: breakStatement : B= BREAK (I= IDENTIFIER )? semic ;
    public final ASCollectorParser.breakStatement_return breakStatement() throws RecognitionException {
        ASCollectorParser.breakStatement_return retval = new ASCollectorParser.breakStatement_return();
        retval.start = input.LT(1);
        int breakStatement_StartIndex = input.index();
        Object root_0 = null;

        Token B=null;
        Token I=null;
        ASCollectorParser.semic_return semic168 = null;


        Object B_tree=null;
        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return retval; }
            // ASCollector.g3:1918:5: (B= BREAK (I= IDENTIFIER )? semic )
            // ASCollector.g3:1918:9: B= BREAK (I= IDENTIFIER )? semic
            {
            root_0 = (Object)adaptor.nil();

            B=(Token)match(input,BREAK,FOLLOW_BREAK_in_breakStatement9293); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            B_tree = (Object)adaptor.create(B);
            adaptor.addChild(root_0, B_tree);
            }
            // ASCollector.g3:1918:21: (I= IDENTIFIER )?
            int alt96=2;
            int LA96_0 = input.LA(1);

            if ( (LA96_0==IDENTIFIER) ) {
                alt96=1;
            }
            switch (alt96) {
                case 1 :
                    // ASCollector.g3:1918:22: I= IDENTIFIER
                    {
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_breakStatement9302); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_breakStatement9306);
            semic168=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic168.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 73, breakStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "breakStatement"

    public static class continueStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "continueStatement"
    // ASCollector.g3:1926:1: continueStatement : C= CONTINUE (I= IDENTIFIER )? semic ;
    public final ASCollectorParser.continueStatement_return continueStatement() throws RecognitionException {
        ASCollectorParser.continueStatement_return retval = new ASCollectorParser.continueStatement_return();
        retval.start = input.LT(1);
        int continueStatement_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        Token I=null;
        ASCollectorParser.semic_return semic169 = null;


        Object C_tree=null;
        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return retval; }
            // ASCollector.g3:1927:5: (C= CONTINUE (I= IDENTIFIER )? semic )
            // ASCollector.g3:1927:9: C= CONTINUE (I= IDENTIFIER )? semic
            {
            root_0 = (Object)adaptor.nil();

            C=(Token)match(input,CONTINUE,FOLLOW_CONTINUE_in_continueStatement9332); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            C_tree = (Object)adaptor.create(C);
            adaptor.addChild(root_0, C_tree);
            }
            // ASCollector.g3:1927:21: (I= IDENTIFIER )?
            int alt97=2;
            int LA97_0 = input.LA(1);

            if ( (LA97_0==IDENTIFIER) ) {
                alt97=1;
            }
            switch (alt97) {
                case 1 :
                    // ASCollector.g3:1927:22: I= IDENTIFIER
                    {
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_continueStatement9338); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_continueStatement9342);
            semic169=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic169.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 74, continueStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "continueStatement"

    public static class forStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forStatement"
    // ASCollector.g3:1935:1: forStatement : F= FOR L= LPAREN forControl R= RPAREN statement ;
    public final ASCollectorParser.forStatement_return forStatement() throws RecognitionException {
        ASCollectorParser.forStatement_return retval = new ASCollectorParser.forStatement_return();
        retval.start = input.LT(1);
        int forStatement_StartIndex = input.index();
        Object root_0 = null;

        Token F=null;
        Token L=null;
        Token R=null;
        ASCollectorParser.forControl_return forControl170 = null;

        ASCollectorParser.statement_return statement171 = null;


        Object F_tree=null;
        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return retval; }
            // ASCollector.g3:1936:5: (F= FOR L= LPAREN forControl R= RPAREN statement )
            // ASCollector.g3:1936:9: F= FOR L= LPAREN forControl R= RPAREN statement
            {
            root_0 = (Object)adaptor.nil();

            F=(Token)match(input,FOR,FOLLOW_FOR_in_forStatement9368); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            F_tree = (Object)adaptor.create(F);
            adaptor.addChild(root_0, F_tree);
            }
            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forStatement9374); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_forControl_in_forStatement9377);
            forControl170=forControl();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, forControl170.getTree());
            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forStatement9381); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            pushFollow(FOLLOW_statement_in_forStatement9384);
            statement171=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement171.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 75, forStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forStatement"

    public static class forInStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forInStatement"
    // ASCollector.g3:1939:1: forInStatement : F= FOR L= LPAREN forInControl R= RPAREN statement ;
    public final ASCollectorParser.forInStatement_return forInStatement() throws RecognitionException {
        ASCollectorParser.forInStatement_return retval = new ASCollectorParser.forInStatement_return();
        retval.start = input.LT(1);
        int forInStatement_StartIndex = input.index();
        Object root_0 = null;

        Token F=null;
        Token L=null;
        Token R=null;
        ASCollectorParser.forInControl_return forInControl172 = null;

        ASCollectorParser.statement_return statement173 = null;


        Object F_tree=null;
        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return retval; }
            // ASCollector.g3:1940:5: (F= FOR L= LPAREN forInControl R= RPAREN statement )
            // ASCollector.g3:1940:9: F= FOR L= LPAREN forInControl R= RPAREN statement
            {
            root_0 = (Object)adaptor.nil();

            F=(Token)match(input,FOR,FOLLOW_FOR_in_forInStatement9410); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            F_tree = (Object)adaptor.create(F);
            adaptor.addChild(root_0, F_tree);
            }
            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forInStatement9416); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_forInControl_in_forInStatement9419);
            forInControl172=forInControl();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, forInControl172.getTree());
            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forInStatement9423); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            pushFollow(FOLLOW_statement_in_forInStatement9428);
            statement173=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement173.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 76, forInStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forInStatement"

    public static class forEachInStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forEachInStatement"
    // ASCollector.g3:1943:1: forEachInStatement : F= FOR E= EACH L= LPAREN forInControl R= RPAREN statement ;
    public final ASCollectorParser.forEachInStatement_return forEachInStatement() throws RecognitionException {
        ASCollectorParser.forEachInStatement_return retval = new ASCollectorParser.forEachInStatement_return();
        retval.start = input.LT(1);
        int forEachInStatement_StartIndex = input.index();
        Object root_0 = null;

        Token F=null;
        Token E=null;
        Token L=null;
        Token R=null;
        ASCollectorParser.forInControl_return forInControl174 = null;

        ASCollectorParser.statement_return statement175 = null;


        Object F_tree=null;
        Object E_tree=null;
        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return retval; }
            // ASCollector.g3:1944:5: (F= FOR E= EACH L= LPAREN forInControl R= RPAREN statement )
            // ASCollector.g3:1944:9: F= FOR E= EACH L= LPAREN forInControl R= RPAREN statement
            {
            root_0 = (Object)adaptor.nil();

            F=(Token)match(input,FOR,FOLLOW_FOR_in_forEachInStatement9456); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            F_tree = (Object)adaptor.create(F);
            adaptor.addChild(root_0, F_tree);
            }
            E=(Token)match(input,EACH,FOLLOW_EACH_in_forEachInStatement9472); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            E_tree = (Object)adaptor.create(E);
            adaptor.addChild(root_0, E_tree);
            }
            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forEachInStatement9482); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_forInControl_in_forEachInStatement9485);
            forInControl174=forInControl();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, forInControl174.getTree());
            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forEachInStatement9489); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }
            pushFollow(FOLLOW_statement_in_forEachInStatement9492);
            statement175=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement175.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 77, forEachInStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forEachInStatement"

    public static class forControl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forControl"
    // ASCollector.g3:1949:1: forControl options {k=3; } : ( forInit )? semic ( expression )? semic ( forUpdate )? ;
    public final ASCollectorParser.forControl_return forControl() throws RecognitionException {
        ASCollectorParser.forControl_return retval = new ASCollectorParser.forControl_return();
        retval.start = input.LT(1);
        int forControl_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.forInit_return forInit176 = null;

        ASCollectorParser.semic_return semic177 = null;

        ASCollectorParser.expression_return expression178 = null;

        ASCollectorParser.semic_return semic179 = null;

        ASCollectorParser.forUpdate_return forUpdate180 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return retval; }
            // ASCollector.g3:1951:5: ( ( forInit )? semic ( expression )? semic ( forUpdate )? )
            // ASCollector.g3:1951:9: ( forInit )? semic ( expression )? semic ( forUpdate )?
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:1951:9: ( forInit )?
            int alt98=2;
            int LA98_0 = input.LA(1);

            if ( ((LA98_0>=AS && LA98_0<=STATIC)||LA98_0==LCURLY||LA98_0==LPAREN||LA98_0==LBRACK||LA98_0==LT||(LA98_0>=PLUS && LA98_0<=STAR)||(LA98_0>=INC && LA98_0<=DEC)||(LA98_0>=NOT && LA98_0<=INV)||(LA98_0>=XML_AT && LA98_0<=XML_LS_STD)||(LA98_0>=SINGLE_QUOTE_LITERAL && LA98_0<=DOUBLE_QUOTE_LITERAL)||LA98_0==REGULAR_EXPR_LITERAL||LA98_0==HEX_NUMBER_LITERAL||LA98_0==DEC_NUMBER_LITERAL||LA98_0==IDENTIFIER||(LA98_0>=XML_COMMENT && LA98_0<=XML_PI)) ) {
                alt98=1;
            }
            switch (alt98) {
                case 1 :
                    // ASCollector.g3:0:0: forInit
                    {
                    pushFollow(FOLLOW_forInit_in_forControl9521);
                    forInit176=forInit();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forInit176.getTree());

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_forControl9525);
            semic177=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic177.getTree());
            // ASCollector.g3:1951:27: ( expression )?
            int alt99=2;
            int LA99_0 = input.LA(1);

            if ( ((LA99_0>=AS && LA99_0<=STATIC)||LA99_0==LCURLY||LA99_0==LPAREN||LA99_0==LBRACK||LA99_0==LT||(LA99_0>=PLUS && LA99_0<=STAR)||(LA99_0>=INC && LA99_0<=DEC)||(LA99_0>=NOT && LA99_0<=INV)||(LA99_0>=XML_AT && LA99_0<=XML_LS_STD)||(LA99_0>=SINGLE_QUOTE_LITERAL && LA99_0<=DOUBLE_QUOTE_LITERAL)||LA99_0==REGULAR_EXPR_LITERAL||LA99_0==HEX_NUMBER_LITERAL||LA99_0==DEC_NUMBER_LITERAL||LA99_0==IDENTIFIER||(LA99_0>=XML_COMMENT && LA99_0<=XML_PI)) ) {
                alt99=1;
            }
            switch (alt99) {
                case 1 :
                    // ASCollector.g3:0:0: expression
                    {
                    pushFollow(FOLLOW_expression_in_forControl9529);
                    expression178=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression178.getTree());

                    }
                    break;

            }

            pushFollow(FOLLOW_semic_in_forControl9532);
            semic179=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic179.getTree());
            // ASCollector.g3:1951:46: ( forUpdate )?
            int alt100=2;
            int LA100_0 = input.LA(1);

            if ( ((LA100_0>=AS && LA100_0<=STATIC)||LA100_0==LCURLY||LA100_0==LPAREN||LA100_0==LBRACK||LA100_0==LT||(LA100_0>=PLUS && LA100_0<=STAR)||(LA100_0>=INC && LA100_0<=DEC)||(LA100_0>=NOT && LA100_0<=INV)||(LA100_0>=XML_AT && LA100_0<=XML_LS_STD)||(LA100_0>=SINGLE_QUOTE_LITERAL && LA100_0<=DOUBLE_QUOTE_LITERAL)||LA100_0==REGULAR_EXPR_LITERAL||LA100_0==HEX_NUMBER_LITERAL||LA100_0==DEC_NUMBER_LITERAL||LA100_0==IDENTIFIER||(LA100_0>=XML_COMMENT && LA100_0<=XML_PI)) ) {
                alt100=1;
            }
            switch (alt100) {
                case 1 :
                    // ASCollector.g3:0:0: forUpdate
                    {
                    pushFollow(FOLLOW_forUpdate_in_forControl9535);
                    forUpdate180=forUpdate();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forUpdate180.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 78, forControl_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forControl"

    public static class forInControl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forInControl"
    // ASCollector.g3:1954:1: forInControl options {k=3; } : forInDecl I= IN expression ;
    public final ASCollectorParser.forInControl_return forInControl() throws RecognitionException {
        ASCollectorParser.forInControl_return retval = new ASCollectorParser.forInControl_return();
        retval.start = input.LT(1);
        int forInControl_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        ASCollectorParser.forInDecl_return forInDecl181 = null;

        ASCollectorParser.expression_return expression182 = null;


        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return retval; }
            // ASCollector.g3:1956:5: ( forInDecl I= IN expression )
            // ASCollector.g3:1956:9: forInDecl I= IN expression
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_forInDecl_in_forInControl9563);
            forInDecl181=forInDecl();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, forInDecl181.getTree());
            I=(Token)match(input,IN,FOLLOW_IN_in_forInControl9567); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }
            pushFollow(FOLLOW_expression_in_forInControl9570);
            expression182=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression182.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 79, forInControl_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forInControl"

    public static class forInDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forInDecl"
    // ASCollector.g3:1959:1: forInDecl : ( leftHandSideExpression | V= VAR variableDeclarationNoIn );
    public final ASCollectorParser.forInDecl_return forInDecl() throws RecognitionException {
        ASCollectorParser.forInDecl_return retval = new ASCollectorParser.forInDecl_return();
        retval.start = input.LT(1);
        int forInDecl_StartIndex = input.index();
        Object root_0 = null;

        Token V=null;
        ASCollectorParser.leftHandSideExpression_return leftHandSideExpression183 = null;

        ASCollectorParser.variableDeclarationNoIn_return variableDeclarationNoIn184 = null;


        Object V_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return retval; }
            // ASCollector.g3:1960:5: ( leftHandSideExpression | V= VAR variableDeclarationNoIn )
            int alt101=2;
            int LA101_0 = input.LA(1);

            if ( ((LA101_0>=AS && LA101_0<=USE)||(LA101_0>=VOID && LA101_0<=STATIC)||LA101_0==LCURLY||LA101_0==LPAREN||LA101_0==LBRACK||LA101_0==LT||LA101_0==STAR||(LA101_0>=XML_AT && LA101_0<=XML_LS_STD)||(LA101_0>=SINGLE_QUOTE_LITERAL && LA101_0<=DOUBLE_QUOTE_LITERAL)||LA101_0==REGULAR_EXPR_LITERAL||LA101_0==HEX_NUMBER_LITERAL||LA101_0==DEC_NUMBER_LITERAL||LA101_0==IDENTIFIER||(LA101_0>=XML_COMMENT && LA101_0<=XML_PI)) ) {
                alt101=1;
            }
            else if ( (LA101_0==VAR) ) {
                int LA101_2 = input.LA(2);

                if ( (LA101_2==NATIVE||LA101_2==TO||(LA101_2>=EACH && LA101_2<=NAMESPACE)||(LA101_2>=DYNAMIC && LA101_2<=STATIC)||LA101_2==IDENTIFIER) ) {
                    alt101=2;
                }
                else if ( (LA101_2==DOT||LA101_2==SUB||LA101_2==COLON||LA101_2==XML_NS_OP) ) {
                    alt101=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 101, 2, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 101, 0, input);

                throw nvae;
            }
            switch (alt101) {
                case 1 :
                    // ASCollector.g3:1960:9: leftHandSideExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_leftHandSideExpression_in_forInDecl9589);
                    leftHandSideExpression183=leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, leftHandSideExpression183.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1961:9: V= VAR variableDeclarationNoIn
                    {
                    root_0 = (Object)adaptor.nil();

                    V=(Token)match(input,VAR,FOLLOW_VAR_in_forInDecl9601); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    V_tree = (Object)adaptor.create(V);
                    adaptor.addChild(root_0, V_tree);
                    }
                    pushFollow(FOLLOW_variableDeclarationNoIn_in_forInDecl9604);
                    variableDeclarationNoIn184=variableDeclarationNoIn();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclarationNoIn184.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 80, forInDecl_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forInDecl"

    public static class forInit_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forInit"
    // ASCollector.g3:1964:1: forInit : (V= VAR variableDeclarationNoInList | expressionNoIn );
    public final ASCollectorParser.forInit_return forInit() throws RecognitionException {
        ASCollectorParser.forInit_return retval = new ASCollectorParser.forInit_return();
        retval.start = input.LT(1);
        int forInit_StartIndex = input.index();
        Object root_0 = null;

        Token V=null;
        ASCollectorParser.variableDeclarationNoInList_return variableDeclarationNoInList185 = null;

        ASCollectorParser.expressionNoIn_return expressionNoIn186 = null;


        Object V_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return retval; }
            // ASCollector.g3:1965:5: (V= VAR variableDeclarationNoInList | expressionNoIn )
            int alt102=2;
            int LA102_0 = input.LA(1);

            if ( (LA102_0==VAR) ) {
                int LA102_1 = input.LA(2);

                if ( (LA102_1==DOT||LA102_1==SUB||LA102_1==COLON||LA102_1==XML_NS_OP) ) {
                    alt102=2;
                }
                else if ( (LA102_1==NATIVE||LA102_1==TO||(LA102_1>=EACH && LA102_1<=NAMESPACE)||(LA102_1>=DYNAMIC && LA102_1<=STATIC)||LA102_1==IDENTIFIER) ) {
                    alt102=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 102, 1, input);

                    throw nvae;
                }
            }
            else if ( ((LA102_0>=AS && LA102_0<=USE)||(LA102_0>=VOID && LA102_0<=STATIC)||LA102_0==LCURLY||LA102_0==LPAREN||LA102_0==LBRACK||LA102_0==LT||(LA102_0>=PLUS && LA102_0<=STAR)||(LA102_0>=INC && LA102_0<=DEC)||(LA102_0>=NOT && LA102_0<=INV)||(LA102_0>=XML_AT && LA102_0<=XML_LS_STD)||(LA102_0>=SINGLE_QUOTE_LITERAL && LA102_0<=DOUBLE_QUOTE_LITERAL)||LA102_0==REGULAR_EXPR_LITERAL||LA102_0==HEX_NUMBER_LITERAL||LA102_0==DEC_NUMBER_LITERAL||LA102_0==IDENTIFIER||(LA102_0>=XML_COMMENT && LA102_0<=XML_PI)) ) {
                alt102=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 102, 0, input);

                throw nvae;
            }
            switch (alt102) {
                case 1 :
                    // ASCollector.g3:1965:9: V= VAR variableDeclarationNoInList
                    {
                    root_0 = (Object)adaptor.nil();

                    V=(Token)match(input,VAR,FOLLOW_VAR_in_forInit9625); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    V_tree = (Object)adaptor.create(V);
                    adaptor.addChild(root_0, V_tree);
                    }
                    pushFollow(FOLLOW_variableDeclarationNoInList_in_forInit9627);
                    variableDeclarationNoInList185=variableDeclarationNoInList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclarationNoInList185.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:1966:9: expressionNoIn
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_expressionNoIn_in_forInit9637);
                    expressionNoIn186=expressionNoIn();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expressionNoIn186.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 81, forInit_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forInit"

    public static class forUpdate_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forUpdate"
    // ASCollector.g3:1969:1: forUpdate : expression ;
    public final ASCollectorParser.forUpdate_return forUpdate() throws RecognitionException {
        ASCollectorParser.forUpdate_return retval = new ASCollectorParser.forUpdate_return();
        retval.start = input.LT(1);
        int forUpdate_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.expression_return expression187 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return retval; }
            // ASCollector.g3:1970:5: ( expression )
            // ASCollector.g3:1970:9: expression
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_expression_in_forUpdate9656);
            expression187=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression187.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 82, forUpdate_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forUpdate"

    public static class doWhileStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "doWhileStatement"
    // ASCollector.g3:1978:1: doWhileStatement : D= DO statement W= WHILE parExpression semic (S= SEMI )? ;
    public final ASCollectorParser.doWhileStatement_return doWhileStatement() throws RecognitionException {
        ASCollectorParser.doWhileStatement_return retval = new ASCollectorParser.doWhileStatement_return();
        retval.start = input.LT(1);
        int doWhileStatement_StartIndex = input.index();
        Object root_0 = null;

        Token D=null;
        Token W=null;
        Token S=null;
        ASCollectorParser.statement_return statement188 = null;

        ASCollectorParser.parExpression_return parExpression189 = null;

        ASCollectorParser.semic_return semic190 = null;


        Object D_tree=null;
        Object W_tree=null;
        Object S_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return retval; }
            // ASCollector.g3:1979:5: (D= DO statement W= WHILE parExpression semic (S= SEMI )? )
            // ASCollector.g3:1979:9: D= DO statement W= WHILE parExpression semic (S= SEMI )?
            {
            root_0 = (Object)adaptor.nil();

            D=(Token)match(input,DO,FOLLOW_DO_in_doWhileStatement9682); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            D_tree = (Object)adaptor.create(D);
            adaptor.addChild(root_0, D_tree);
            }
            pushFollow(FOLLOW_statement_in_doWhileStatement9686);
            statement188=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement188.getTree());
            W=(Token)match(input,WHILE,FOLLOW_WHILE_in_doWhileStatement9692); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            W_tree = (Object)adaptor.create(W);
            adaptor.addChild(root_0, W_tree);
            }
            pushFollow(FOLLOW_parExpression_in_doWhileStatement9695);
            parExpression189=parExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression189.getTree());
            pushFollow(FOLLOW_semic_in_doWhileStatement9697);
            semic190=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, semic190.getTree());
            // ASCollector.g3:1979:57: (S= SEMI )?
            int alt103=2;
            int LA103_0 = input.LA(1);

            if ( (LA103_0==SEMI) ) {
                int LA103_1 = input.LA(2);

                if ( (synpred221_ASCollector()) ) {
                    alt103=1;
                }
            }
            switch (alt103) {
                case 1 :
                    // ASCollector.g3:1979:58: S= SEMI
                    {
                    S=(Token)match(input,SEMI,FOLLOW_SEMI_in_doWhileStatement9702); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 83, doWhileStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "doWhileStatement"

    public static class whileStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "whileStatement"
    // ASCollector.g3:1986:1: whileStatement : W= WHILE parExpression statement ;
    public final ASCollectorParser.whileStatement_return whileStatement() throws RecognitionException {
        ASCollectorParser.whileStatement_return retval = new ASCollectorParser.whileStatement_return();
        retval.start = input.LT(1);
        int whileStatement_StartIndex = input.index();
        Object root_0 = null;

        Token W=null;
        ASCollectorParser.parExpression_return parExpression191 = null;

        ASCollectorParser.statement_return statement192 = null;


        Object W_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return retval; }
            // ASCollector.g3:1987:5: (W= WHILE parExpression statement )
            // ASCollector.g3:1987:9: W= WHILE parExpression statement
            {
            root_0 = (Object)adaptor.nil();

            W=(Token)match(input,WHILE,FOLLOW_WHILE_in_whileStatement9730); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            W_tree = (Object)adaptor.create(W);
            adaptor.addChild(root_0, W_tree);
            }
            pushFollow(FOLLOW_parExpression_in_whileStatement9733);
            parExpression191=parExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression191.getTree());
            pushFollow(FOLLOW_statement_in_whileStatement9737);
            statement192=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement192.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 84, whileStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "whileStatement"

    public static class ifStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "ifStatement"
    // ASCollector.g3:1996:1: ifStatement : I= IF parExpression statement ( options {k=1; } : E= ELSE statement )? ;
    public final ASCollectorParser.ifStatement_return ifStatement() throws RecognitionException {
        ASCollectorParser.ifStatement_return retval = new ASCollectorParser.ifStatement_return();
        retval.start = input.LT(1);
        int ifStatement_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        Token E=null;
        ASCollectorParser.parExpression_return parExpression193 = null;

        ASCollectorParser.statement_return statement194 = null;

        ASCollectorParser.statement_return statement195 = null;


        Object I_tree=null;
        Object E_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return retval; }
            // ASCollector.g3:1997:5: (I= IF parExpression statement ( options {k=1; } : E= ELSE statement )? )
            // ASCollector.g3:1999:10: I= IF parExpression statement ( options {k=1; } : E= ELSE statement )?
            {
            root_0 = (Object)adaptor.nil();

            I=(Token)match(input,IF,FOLLOW_IF_in_ifStatement9791); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }
            pushFollow(FOLLOW_parExpression_in_ifStatement9814);
            parExpression193=parExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression193.getTree());
            pushFollow(FOLLOW_statement_in_ifStatement9846);
            statement194=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement194.getTree());
            // ASCollector.g3:2007:10: ( options {k=1; } : E= ELSE statement )?
            int alt104=2;
            int LA104_0 = input.LA(1);

            if ( (LA104_0==ELSE) ) {
                int LA104_2 = input.LA(2);

                if ( (synpred222_ASCollector()) ) {
                    alt104=1;
                }
            }
            switch (alt104) {
                case 1 :
                    // ASCollector.g3:2007:26: E= ELSE statement
                    {
                    E=(Token)match(input,ELSE,FOLLOW_ELSE_in_ifStatement9889); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    E_tree = (Object)adaptor.create(E);
                    adaptor.addChild(root_0, E_tree);
                    }
                    pushFollow(FOLLOW_statement_in_ifStatement9925);
                    statement195=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement195.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 85, ifStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "ifStatement"

    public static class emptyStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "emptyStatement"
    // ASCollector.g3:2020:1: emptyStatement : S= SEMI ;
    public final ASCollectorParser.emptyStatement_return emptyStatement() throws RecognitionException {
        ASCollectorParser.emptyStatement_return retval = new ASCollectorParser.emptyStatement_return();
        retval.start = input.LT(1);
        int emptyStatement_StartIndex = input.index();
        Object root_0 = null;

        Token S=null;

        Object S_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return retval; }
            // ASCollector.g3:2021:5: (S= SEMI )
            // ASCollector.g3:2021:11: S= SEMI
            {
            root_0 = (Object)adaptor.nil();

            S=(Token)match(input,SEMI,FOLLOW_SEMI_in_emptyStatement9986); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            S_tree = (Object)adaptor.create(S);
            adaptor.addChild(root_0, S_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 86, emptyStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "emptyStatement"

    public static class variableStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableStatement"
    // ASCollector.g3:2029:1: variableStatement[PropertyLine prop] : (I= IDENTIFIER )? V= VAR lastTree= variableDeclaration[prop] (C= COMMA lastTree= variableDeclaration[prop] )* s= semic ;
    public final ASCollectorParser.variableStatement_return variableStatement(PropertyLine prop) throws RecognitionException {
        ASCollectorParser.variableStatement_return retval = new ASCollectorParser.variableStatement_return();
        retval.start = input.LT(1);
        int variableStatement_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        Token V=null;
        Token C=null;
        ASCollectorParser.variableDeclaration_return lastTree = null;

        ASCollectorParser.semic_return s = null;


        Object I_tree=null;
        Object V_tree=null;
        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return retval; }
            // ASCollector.g3:2030:5: ( (I= IDENTIFIER )? V= VAR lastTree= variableDeclaration[prop] (C= COMMA lastTree= variableDeclaration[prop] )* s= semic )
            // ASCollector.g3:2031:9: (I= IDENTIFIER )? V= VAR lastTree= variableDeclaration[prop] (C= COMMA lastTree= variableDeclaration[prop] )* s= semic
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:2031:9: (I= IDENTIFIER )?
            int alt105=2;
            int LA105_0 = input.LA(1);

            if ( (LA105_0==IDENTIFIER) ) {
                alt105=1;
            }
            switch (alt105) {
                case 1 :
                    // ASCollector.g3:2031:10: I= IDENTIFIER
                    {
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableStatement10023); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;

            }

            V=(Token)match(input,VAR,FOLLOW_VAR_in_variableStatement10030); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            V_tree = (Object)adaptor.create(V);
            adaptor.addChild(root_0, V_tree);
            }
            pushFollow(FOLLOW_variableDeclaration_in_variableStatement10052);
            lastTree=variableDeclaration(prop);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, lastTree.getTree());
            // ASCollector.g3:2040:46: (C= COMMA lastTree= variableDeclaration[prop] )*
            loop106:
            do {
                int alt106=2;
                int LA106_0 = input.LA(1);

                if ( (LA106_0==COMMA) ) {
                    alt106=1;
                }


                switch (alt106) {
            	case 1 :
            	    // ASCollector.g3:2040:48: C= COMMA lastTree= variableDeclaration[prop]
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_variableStatement10059); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_variableDeclaration_in_variableStatement10064);
            	    lastTree=variableDeclaration(prop);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, lastTree.getTree());

            	    }
            	    break;

            	default :
            	    break loop106;
                }
            } while (true);

            pushFollow(FOLLOW_semic_in_variableStatement10072);
            s=semic();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, s.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 87, variableStatement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "variableStatement"

    public static class variableDeclarationList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableDeclarationList"
    // ASCollector.g3:2054:1: variableDeclarationList[DeclHolder holder] : variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* ;
    public final ASCollectorParser.variableDeclarationList_return variableDeclarationList(DeclHolder holder) throws RecognitionException {
        ASCollectorParser.variableDeclarationList_return retval = new ASCollectorParser.variableDeclarationList_return();
        retval.start = input.LT(1);
        int variableDeclarationList_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.variableDeclaration_return variableDeclaration196 = null;

        ASCollectorParser.variableDeclaration_return variableDeclaration197 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return retval; }
            // ASCollector.g3:2055:5: ( variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )* )
            // ASCollector.g3:2055:11: variableDeclaration[holder] (C= COMMA variableDeclaration[holder] )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_variableDeclaration_in_variableDeclarationList10123);
            variableDeclaration196=variableDeclaration(holder);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclaration196.getTree());
            // ASCollector.g3:2055:39: (C= COMMA variableDeclaration[holder] )*
            loop107:
            do {
                int alt107=2;
                int LA107_0 = input.LA(1);

                if ( (LA107_0==COMMA) ) {
                    alt107=1;
                }


                switch (alt107) {
            	case 1 :
            	    // ASCollector.g3:2055:42: C= COMMA variableDeclaration[holder]
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_variableDeclarationList10131); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_variableDeclaration_in_variableDeclarationList10134);
            	    variableDeclaration197=variableDeclaration(holder);

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclaration197.getTree());

            	    }
            	    break;

            	default :
            	    break loop107;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 88, variableDeclarationList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "variableDeclarationList"

    public static class variableDeclarationNoInList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableDeclarationNoInList"
    // ASCollector.g3:2058:1: variableDeclarationNoInList : variableDeclarationNoIn (C= COMMA variableDeclarationNoIn )* ;
    public final ASCollectorParser.variableDeclarationNoInList_return variableDeclarationNoInList() throws RecognitionException {
        ASCollectorParser.variableDeclarationNoInList_return retval = new ASCollectorParser.variableDeclarationNoInList_return();
        retval.start = input.LT(1);
        int variableDeclarationNoInList_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.variableDeclarationNoIn_return variableDeclarationNoIn198 = null;

        ASCollectorParser.variableDeclarationNoIn_return variableDeclarationNoIn199 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return retval; }
            // ASCollector.g3:2059:5: ( variableDeclarationNoIn (C= COMMA variableDeclarationNoIn )* )
            // ASCollector.g3:2059:10: variableDeclarationNoIn (C= COMMA variableDeclarationNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_variableDeclarationNoIn_in_variableDeclarationNoInList10161);
            variableDeclarationNoIn198=variableDeclarationNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclarationNoIn198.getTree());
            // ASCollector.g3:2059:34: (C= COMMA variableDeclarationNoIn )*
            loop108:
            do {
                int alt108=2;
                int LA108_0 = input.LA(1);

                if ( (LA108_0==COMMA) ) {
                    alt108=1;
                }


                switch (alt108) {
            	case 1 :
            	    // ASCollector.g3:2059:37: C= COMMA variableDeclarationNoIn
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_variableDeclarationNoInList10168); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_variableDeclarationNoIn_in_variableDeclarationNoInList10171);
            	    variableDeclarationNoIn199=variableDeclarationNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclarationNoIn199.getTree());

            	    }
            	    break;

            	default :
            	    break loop108;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 89, variableDeclarationNoInList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "variableDeclarationNoInList"

    public static class variableDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableDeclaration"
    // ASCollector.g3:2062:1: variableDeclaration[DeclHolder prop] : d= variableIdentifierDecl[prop] (A= ASSIGN val= assignmentExpression )? ;
    public final ASCollectorParser.variableDeclaration_return variableDeclaration(DeclHolder prop) throws RecognitionException {
        ASCollectorParser.variableDeclaration_return retval = new ASCollectorParser.variableDeclaration_return();
        retval.start = input.LT(1);
        int variableDeclaration_StartIndex = input.index();
        Object root_0 = null;

        Token A=null;
        ASCollectorParser.variableIdentifierDecl_return d = null;

        ASCollectorParser.assignmentExpression_return val = null;


        Object A_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return retval; }
            // ASCollector.g3:2063:5: (d= variableIdentifierDecl[prop] (A= ASSIGN val= assignmentExpression )? )
            // ASCollector.g3:2063:9: d= variableIdentifierDecl[prop] (A= ASSIGN val= assignmentExpression )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_variableIdentifierDecl_in_variableDeclaration10199);
            d=variableIdentifierDecl(prop);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, d.getTree());
            // ASCollector.g3:2064:6: (A= ASSIGN val= assignmentExpression )?
            int alt109=2;
            int LA109_0 = input.LA(1);

            if ( (LA109_0==ASSIGN) ) {
                alt109=1;
            }
            switch (alt109) {
                case 1 :
                    // ASCollector.g3:2064:8: A= ASSIGN val= assignmentExpression
                    {
                    A=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_variableDeclaration10212); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    A_tree = (Object)adaptor.create(A);
                    adaptor.addChild(root_0, A_tree);
                    }
                    pushFollow(FOLLOW_assignmentExpression_in_variableDeclaration10216);
                    val=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, val.getTree());

                    }
                    break;

            }

            if ( state.backtracking==0 ) {

                  		if (prop!=null)
                  		{
              //    			if (val!=null)
                //  				prop.captureEndPos(val);
                  //			else
                  	//			prop.captureEndPos(d);
                  		}
                  	
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 90, variableDeclaration_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "variableDeclaration"

    public static class variableDeclarationNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableDeclarationNoIn"
    // ASCollector.g3:2077:1: variableDeclarationNoIn : variableIdentifierDecl[null] (A= ASSIGN assignmentExpressionNoIn )? ;
    public final ASCollectorParser.variableDeclarationNoIn_return variableDeclarationNoIn() throws RecognitionException {
        ASCollectorParser.variableDeclarationNoIn_return retval = new ASCollectorParser.variableDeclarationNoIn_return();
        retval.start = input.LT(1);
        int variableDeclarationNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token A=null;
        ASCollectorParser.variableIdentifierDecl_return variableIdentifierDecl200 = null;

        ASCollectorParser.assignmentExpressionNoIn_return assignmentExpressionNoIn201 = null;


        Object A_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return retval; }
            // ASCollector.g3:2078:5: ( variableIdentifierDecl[null] (A= ASSIGN assignmentExpressionNoIn )? )
            // ASCollector.g3:2078:10: variableIdentifierDecl[null] (A= ASSIGN assignmentExpressionNoIn )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_variableIdentifierDecl_in_variableDeclarationNoIn10252);
            variableIdentifierDecl200=variableIdentifierDecl(null);

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableIdentifierDecl200.getTree());
            // ASCollector.g3:2078:39: (A= ASSIGN assignmentExpressionNoIn )?
            int alt110=2;
            int LA110_0 = input.LA(1);

            if ( (LA110_0==ASSIGN) ) {
                alt110=1;
            }
            switch (alt110) {
                case 1 :
                    // ASCollector.g3:2078:41: A= ASSIGN assignmentExpressionNoIn
                    {
                    A=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_variableDeclarationNoIn10259); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    A_tree = (Object)adaptor.create(A);
                    adaptor.addChild(root_0, A_tree);
                    }
                    pushFollow(FOLLOW_assignmentExpressionNoIn_in_variableDeclarationNoIn10262);
                    assignmentExpressionNoIn201=assignmentExpressionNoIn();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpressionNoIn201.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 91, variableDeclarationNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "variableDeclarationNoIn"

    public static class variableIdentifierDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "variableIdentifierDecl"
    // ASCollector.g3:2082:1: variableIdentifierDecl[DeclHolder holder] : id= identifierLiteral (C= COLON t= type )? ;
    public final ASCollectorParser.variableIdentifierDecl_return variableIdentifierDecl(DeclHolder holder) throws RecognitionException {
        ASCollectorParser.variableIdentifierDecl_return retval = new ASCollectorParser.variableIdentifierDecl_return();
        retval.start = input.LT(1);
        int variableIdentifierDecl_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.identifierLiteral_return id = null;

        ASCollectorParser.type_return t = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return retval; }
            // ASCollector.g3:2083:5: (id= identifierLiteral (C= COLON t= type )? )
            // ASCollector.g3:2083:10: id= identifierLiteral (C= COLON t= type )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_identifierLiteral_in_variableIdentifierDecl10293);
            id=identifierLiteral();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, id.getTree());
            // ASCollector.g3:2083:31: (C= COLON t= type )?
            int alt111=2;
            int LA111_0 = input.LA(1);

            if ( (LA111_0==COLON) ) {
                alt111=1;
            }
            switch (alt111) {
                case 1 :
                    // ASCollector.g3:2083:33: C= COLON t= type
                    {
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_variableIdentifierDecl10299); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_type_in_variableIdentifierDecl10304);
                    t=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, t.getTree());

                    }
                    break;

            }

            if ( state.backtracking==0 ) {

              			if (holder!=null)
              			{
              				DeclRecord rec=new DeclRecord(id, t);
              				holder.addDecl(rec);
              			}
                  		
                  	
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 92, variableIdentifierDecl_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "variableIdentifierDecl"

    public static class type_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "type"
    // ASCollector.g3:2097:1: type : ( qualifiedName | S= STAR | V= VOID );
    public final ASCollectorParser.type_return type() throws RecognitionException {
        ASCollectorParser.type_return retval = new ASCollectorParser.type_return();
        retval.start = input.LT(1);
        int type_StartIndex = input.index();
        Object root_0 = null;

        Token S=null;
        Token V=null;
        ASCollectorParser.qualifiedName_return qualifiedName202 = null;


        Object S_tree=null;
        Object V_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return retval; }
            // ASCollector.g3:2097:5: ( qualifiedName | S= STAR | V= VOID )
            int alt112=3;
            switch ( input.LA(1) ) {
            case DEFAULT:
            case INTERNAL:
            case NATIVE:
            case TO:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case IDENTIFIER:
                {
                alt112=1;
                }
                break;
            case STAR:
                {
                alt112=2;
                }
                break;
            case VOID:
                {
                alt112=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 112, 0, input);

                throw nvae;
            }

            switch (alt112) {
                case 1 :
                    // ASCollector.g3:2097:9: qualifiedName
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_qualifiedName_in_type10335);
                    qualifiedName202=qualifiedName();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, qualifiedName202.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2097:25: S= STAR
                    {
                    root_0 = (Object)adaptor.nil();

                    S=(Token)match(input,STAR,FOLLOW_STAR_in_type10341); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2097:35: V= VOID
                    {
                    root_0 = (Object)adaptor.nil();

                    V=(Token)match(input,VOID,FOLLOW_VOID_in_type10348); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    V_tree = (Object)adaptor.create(V);
                    adaptor.addChild(root_0, V_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 93, type_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "type"

    public static class typeList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typeList"
    // ASCollector.g3:2099:1: typeList : t1= type (C= COMMA t2= type )* ;
    public final ASCollectorParser.typeList_return typeList() throws RecognitionException {
        ASCollectorParser.typeList_return retval = new ASCollectorParser.typeList_return();
        retval.start = input.LT(1);
        int typeList_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.type_return t1 = null;

        ASCollectorParser.type_return t2 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return retval; }
            // ASCollector.g3:2100:5: (t1= type (C= COMMA t2= type )* )
            // ASCollector.g3:2100:9: t1= type (C= COMMA t2= type )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_type_in_typeList10366);
            t1=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, t1.getTree());
            if ( state.backtracking==0 ) {

                   		if (getTextHandler()!=null)
                   			getTextHandler().addItem(t1);
                   	
            }
            // ASCollector.g3:2105:8: (C= COMMA t2= type )*
            loop113:
            do {
                int alt113=2;
                int LA113_0 = input.LA(1);

                if ( (LA113_0==COMMA) ) {
                    alt113=1;
                }


                switch (alt113) {
            	case 1 :
            	    // ASCollector.g3:2105:9: C= COMMA t2= type
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeList10386); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_type_in_typeList10390);
            	    t2=type();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, t2.getTree());
            	    if ( state.backtracking==0 ) {

            	           		if (getTextHandler()!=null)
            	           			getTextHandler().addItem(t2);
            	           	
            	    }

            	    }
            	    break;

            	default :
            	    break loop113;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 94, typeList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "typeList"

    public static class standardQualifiedName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "standardQualifiedName"
    // ASCollector.g3:2115:1: standardQualifiedName : typeSpecifier (D= DOT typeSpecifier )* ;
    public final ASCollectorParser.standardQualifiedName_return standardQualifiedName() throws RecognitionException {
        ASCollectorParser.standardQualifiedName_return retval = new ASCollectorParser.standardQualifiedName_return();
        retval.start = input.LT(1);
        int standardQualifiedName_StartIndex = input.index();
        Object root_0 = null;

        Token D=null;
        ASCollectorParser.typeSpecifier_return typeSpecifier203 = null;

        ASCollectorParser.typeSpecifier_return typeSpecifier204 = null;


        Object D_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return retval; }
            // ASCollector.g3:2116:2: ( typeSpecifier (D= DOT typeSpecifier )* )
            // ASCollector.g3:2117:2: typeSpecifier (D= DOT typeSpecifier )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_typeSpecifier_in_standardQualifiedName10439);
            typeSpecifier203=typeSpecifier();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, typeSpecifier203.getTree());
            // ASCollector.g3:2117:16: (D= DOT typeSpecifier )*
            loop114:
            do {
                int alt114=2;
                int LA114_0 = input.LA(1);

                if ( (LA114_0==DOT) ) {
                    int LA114_1 = input.LA(2);

                    if ( (LA114_1==DEFAULT||LA114_1==INTERNAL||LA114_1==NATIVE||LA114_1==TO||(LA114_1>=EACH && LA114_1<=NAMESPACE)||(LA114_1>=DYNAMIC && LA114_1<=STATIC)||LA114_1==IDENTIFIER) ) {
                        alt114=1;
                    }


                }


                switch (alt114) {
            	case 1 :
            	    // ASCollector.g3:2117:17: D= DOT typeSpecifier
            	    {
            	    D=(Token)match(input,DOT,FOLLOW_DOT_in_standardQualifiedName10444); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    D_tree = (Object)adaptor.create(D);
            	    adaptor.addChild(root_0, D_tree);
            	    }
            	    pushFollow(FOLLOW_typeSpecifier_in_standardQualifiedName10447);
            	    typeSpecifier204=typeSpecifier();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, typeSpecifier204.getTree());

            	    }
            	    break;

            	default :
            	    break loop114;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 95, standardQualifiedName_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "standardQualifiedName"

    public static class qualifiedName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "qualifiedName"
    // ASCollector.g3:2121:1: qualifiedName : standardQualifiedName ( typePostfixSyntax )? ;
    public final ASCollectorParser.qualifiedName_return qualifiedName() throws RecognitionException {
        ASCollectorParser.qualifiedName_return retval = new ASCollectorParser.qualifiedName_return();
        retval.start = input.LT(1);
        int qualifiedName_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.standardQualifiedName_return standardQualifiedName205 = null;

        ASCollectorParser.typePostfixSyntax_return typePostfixSyntax206 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return retval; }
            // ASCollector.g3:2122:5: ( standardQualifiedName ( typePostfixSyntax )? )
            // ASCollector.g3:2123:6: standardQualifiedName ( typePostfixSyntax )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_standardQualifiedName_in_qualifiedName10475);
            standardQualifiedName205=standardQualifiedName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, standardQualifiedName205.getTree());
            // ASCollector.g3:2123:28: ( typePostfixSyntax )?
            int alt115=2;
            int LA115_0 = input.LA(1);

            if ( (LA115_0==DOT) ) {
                int LA115_1 = input.LA(2);

                if ( (LA115_1==LT) ) {
                    alt115=1;
                }
            }
            switch (alt115) {
                case 1 :
                    // ASCollector.g3:2123:29: typePostfixSyntax
                    {
                    pushFollow(FOLLOW_typePostfixSyntax_in_qualifiedName10478);
                    typePostfixSyntax206=typePostfixSyntax();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, typePostfixSyntax206.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 96, qualifiedName_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "qualifiedName"

    public static class typePostfixSyntax_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typePostfixSyntax"
    // ASCollector.g3:2126:1: typePostfixSyntax : D= DOT L= LT ( standardQualifiedName | STAR ) ( typePostfixSyntax )? G= GT ;
    public final ASCollectorParser.typePostfixSyntax_return typePostfixSyntax() throws RecognitionException {
        ASCollectorParser.typePostfixSyntax_return retval = new ASCollectorParser.typePostfixSyntax_return();
        retval.start = input.LT(1);
        int typePostfixSyntax_StartIndex = input.index();
        Object root_0 = null;

        Token D=null;
        Token L=null;
        Token G=null;
        Token STAR208=null;
        ASCollectorParser.standardQualifiedName_return standardQualifiedName207 = null;

        ASCollectorParser.typePostfixSyntax_return typePostfixSyntax209 = null;


        Object D_tree=null;
        Object L_tree=null;
        Object G_tree=null;
        Object STAR208_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return retval; }
            // ASCollector.g3:2126:18: (D= DOT L= LT ( standardQualifiedName | STAR ) ( typePostfixSyntax )? G= GT )
            // ASCollector.g3:2127:2: D= DOT L= LT ( standardQualifiedName | STAR ) ( typePostfixSyntax )? G= GT
            {
            root_0 = (Object)adaptor.nil();

            D=(Token)match(input,DOT,FOLLOW_DOT_in_typePostfixSyntax10500); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            D_tree = (Object)adaptor.create(D);
            adaptor.addChild(root_0, D_tree);
            }
            L=(Token)match(input,LT,FOLLOW_LT_in_typePostfixSyntax10505); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:2127:15: ( standardQualifiedName | STAR )
            int alt116=2;
            int LA116_0 = input.LA(1);

            if ( (LA116_0==DEFAULT||LA116_0==INTERNAL||LA116_0==NATIVE||LA116_0==TO||(LA116_0>=EACH && LA116_0<=NAMESPACE)||(LA116_0>=DYNAMIC && LA116_0<=STATIC)||LA116_0==IDENTIFIER) ) {
                alt116=1;
            }
            else if ( (LA116_0==STAR) ) {
                alt116=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 116, 0, input);

                throw nvae;
            }
            switch (alt116) {
                case 1 :
                    // ASCollector.g3:2127:16: standardQualifiedName
                    {
                    pushFollow(FOLLOW_standardQualifiedName_in_typePostfixSyntax10509);
                    standardQualifiedName207=standardQualifiedName();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, standardQualifiedName207.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2127:40: STAR
                    {
                    STAR208=(Token)match(input,STAR,FOLLOW_STAR_in_typePostfixSyntax10513); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    STAR208_tree = (Object)adaptor.create(STAR208);
                    adaptor.addChild(root_0, STAR208_tree);
                    }

                    }
                    break;

            }

            // ASCollector.g3:2127:46: ( typePostfixSyntax )?
            int alt117=2;
            int LA117_0 = input.LA(1);

            if ( (LA117_0==DOT) ) {
                alt117=1;
            }
            switch (alt117) {
                case 1 :
                    // ASCollector.g3:2127:47: typePostfixSyntax
                    {
                    pushFollow(FOLLOW_typePostfixSyntax_in_typePostfixSyntax10517);
                    typePostfixSyntax209=typePostfixSyntax();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, typePostfixSyntax209.getTree());

                    }
                    break;

            }

            G=(Token)match(input,GT,FOLLOW_GT_in_typePostfixSyntax10524); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            G_tree = (Object)adaptor.create(G);
            adaptor.addChild(root_0, G_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 97, typePostfixSyntax_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "typePostfixSyntax"

    public static class qualifiedIdentifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "qualifiedIdentifier"
    // ASCollector.g3:2131:1: qualifiedIdentifier : I= IDENTIFIER ;
    public final ASCollectorParser.qualifiedIdentifier_return qualifiedIdentifier() throws RecognitionException {
        ASCollectorParser.qualifiedIdentifier_return retval = new ASCollectorParser.qualifiedIdentifier_return();
        retval.start = input.LT(1);
        int qualifiedIdentifier_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;

        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return retval; }
            // ASCollector.g3:2132:5: (I= IDENTIFIER )
            // ASCollector.g3:2133:6: I= IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();

            I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedIdentifier10553); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            I_tree = (Object)adaptor.create(I);
            adaptor.addChild(root_0, I_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 98, qualifiedIdentifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "qualifiedIdentifier"

    public static class parExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "parExpression"
    // ASCollector.g3:2139:1: parExpression : L= LPAREN expression R= RPAREN ;
    public final ASCollectorParser.parExpression_return parExpression() throws RecognitionException {
        ASCollectorParser.parExpression_return retval = new ASCollectorParser.parExpression_return();
        retval.start = input.LT(1);
        int parExpression_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.expression_return expression210 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return retval; }
            // ASCollector.g3:2140:5: (L= LPAREN expression R= RPAREN )
            // ASCollector.g3:2140:7: L= LPAREN expression R= RPAREN
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_parExpression10577); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_expression_in_parExpression10582);
            expression210=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression210.getTree());
            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_parExpression10587); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 99, parExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "parExpression"

    public static class expression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expression"
    // ASCollector.g3:2143:1: expression : a= assignmentExpression (C= COMMA a1= assignmentExpression )* ;
    public final ASCollectorParser.expression_return expression() throws RecognitionException {
        ASCollectorParser.expression_return retval = new ASCollectorParser.expression_return();
        retval.start = input.LT(1);
        int expression_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.assignmentExpression_return a = null;

        ASCollectorParser.assignmentExpression_return a1 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return retval; }
            // ASCollector.g3:2144:5: (a= assignmentExpression (C= COMMA a1= assignmentExpression )* )
            // ASCollector.g3:2146:6: a= assignmentExpression (C= COMMA a1= assignmentExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_assignmentExpression_in_expression10623);
            a=assignmentExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, a.getTree());
            // ASCollector.g3:2146:29: (C= COMMA a1= assignmentExpression )*
            loop118:
            do {
                int alt118=2;
                int LA118_0 = input.LA(1);

                if ( (LA118_0==COMMA) ) {
                    int LA118_2 = input.LA(2);

                    if ( (synpred237_ASCollector()) ) {
                        alt118=1;
                    }


                }


                switch (alt118) {
            	case 1 :
            	    // ASCollector.g3:2146:32: C= COMMA a1= assignmentExpression
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_expression10630); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_assignmentExpression_in_expression10636);
            	    a1=assignmentExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, a1.getTree());

            	    }
            	    break;

            	default :
            	    break loop118;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 100, expression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "expression"

    public static class expressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "expressionNoIn"
    // ASCollector.g3:2150:1: expressionNoIn : assignmentExpressionNoIn (C= COMMA assignmentExpressionNoIn )* ;
    public final ASCollectorParser.expressionNoIn_return expressionNoIn() throws RecognitionException {
        ASCollectorParser.expressionNoIn_return retval = new ASCollectorParser.expressionNoIn_return();
        retval.start = input.LT(1);
        int expressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.assignmentExpressionNoIn_return assignmentExpressionNoIn211 = null;

        ASCollectorParser.assignmentExpressionNoIn_return assignmentExpressionNoIn212 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return retval; }
            // ASCollector.g3:2151:5: ( assignmentExpressionNoIn (C= COMMA assignmentExpressionNoIn )* )
            // ASCollector.g3:2151:9: assignmentExpressionNoIn (C= COMMA assignmentExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_assignmentExpressionNoIn_in_expressionNoIn10663);
            assignmentExpressionNoIn211=assignmentExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpressionNoIn211.getTree());
            // ASCollector.g3:2151:34: (C= COMMA assignmentExpressionNoIn )*
            loop119:
            do {
                int alt119=2;
                int LA119_0 = input.LA(1);

                if ( (LA119_0==COMMA) ) {
                    alt119=1;
                }


                switch (alt119) {
            	case 1 :
            	    // ASCollector.g3:2151:37: C= COMMA assignmentExpressionNoIn
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionNoIn10670); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_assignmentExpressionNoIn_in_expressionNoIn10674);
            	    assignmentExpressionNoIn212=assignmentExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpressionNoIn212.getTree());

            	    }
            	    break;

            	default :
            	    break loop119;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 101, expressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "expressionNoIn"

    public static class assignmentExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignmentExpression"
    // ASCollector.g3:2155:1: assignmentExpression : ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpression | conditionalExpression );
    public final ASCollectorParser.assignmentExpression_return assignmentExpression() throws RecognitionException {
        ASCollectorParser.assignmentExpression_return retval = new ASCollectorParser.assignmentExpression_return();
        retval.start = input.LT(1);
        int assignmentExpression_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.leftHandSideExpression_return leftHandSideExpression213 = null;

        ASCollectorParser.assignmentOperator_return assignmentOperator214 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression215 = null;

        ASCollectorParser.conditionalExpression_return conditionalExpression216 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return retval; }
            // ASCollector.g3:2156:5: ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpression | conditionalExpression )
            int alt120=2;
            alt120 = dfa120.predict(input);
            switch (alt120) {
                case 1 :
                    // ASCollector.g3:2157:7: ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_leftHandSideExpression_in_assignmentExpression10711);
                    leftHandSideExpression213=leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, leftHandSideExpression213.getTree());
                    pushFollow(FOLLOW_assignmentOperator_in_assignmentExpression10714);
                    assignmentOperator214=assignmentOperator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentOperator214.getTree());
                    pushFollow(FOLLOW_assignmentExpression_in_assignmentExpression10717);
                    assignmentExpression215=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression215.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2158:7: conditionalExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_conditionalExpression_in_assignmentExpression10725);
                    conditionalExpression216=conditionalExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalExpression216.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 102, assignmentExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "assignmentExpression"

    public static class assignmentExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignmentExpressionNoIn"
    // ASCollector.g3:2162:1: assignmentExpressionNoIn : ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn );
    public final ASCollectorParser.assignmentExpressionNoIn_return assignmentExpressionNoIn() throws RecognitionException {
        ASCollectorParser.assignmentExpressionNoIn_return retval = new ASCollectorParser.assignmentExpressionNoIn_return();
        retval.start = input.LT(1);
        int assignmentExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.leftHandSideExpression_return leftHandSideExpression217 = null;

        ASCollectorParser.assignmentOperator_return assignmentOperator218 = null;

        ASCollectorParser.assignmentExpressionNoIn_return assignmentExpressionNoIn219 = null;

        ASCollectorParser.conditionalExpressionNoIn_return conditionalExpressionNoIn220 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return retval; }
            // ASCollector.g3:2163:5: ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn )
            int alt121=2;
            alt121 = dfa121.predict(input);
            switch (alt121) {
                case 1 :
                    // ASCollector.g3:2164:7: ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_leftHandSideExpression_in_assignmentExpressionNoIn10760);
                    leftHandSideExpression217=leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, leftHandSideExpression217.getTree());
                    pushFollow(FOLLOW_assignmentOperator_in_assignmentExpressionNoIn10763);
                    assignmentOperator218=assignmentOperator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentOperator218.getTree());
                    pushFollow(FOLLOW_assignmentExpressionNoIn_in_assignmentExpressionNoIn10766);
                    assignmentExpressionNoIn219=assignmentExpressionNoIn();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpressionNoIn219.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2165:9: conditionalExpressionNoIn
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_conditionalExpressionNoIn_in_assignmentExpressionNoIn10776);
                    conditionalExpressionNoIn220=conditionalExpressionNoIn();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalExpressionNoIn220.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 103, assignmentExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "assignmentExpressionNoIn"

    public static class assignmentOperator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignmentOperator"
    // ASCollector.g3:2168:1: assignmentOperator : op= assignmentOperator_int ;
    public final ASCollectorParser.assignmentOperator_return assignmentOperator() throws RecognitionException {
        ASCollectorParser.assignmentOperator_return retval = new ASCollectorParser.assignmentOperator_return();
        retval.start = input.LT(1);
        int assignmentOperator_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.assignmentOperator_int_return op = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return retval; }
            // ASCollector.g3:2169:2: (op= assignmentOperator_int )
            // ASCollector.g3:2169:4: op= assignmentOperator_int
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_assignmentOperator_int_in_assignmentOperator10792);
            op=assignmentOperator_int();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, op.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 104, assignmentOperator_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "assignmentOperator"

    public static class assignmentOperator_int_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignmentOperator_int"
    // ASCollector.g3:2173:1: assignmentOperator_int : ( ASSIGN | s= STAR a= ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | ( '>' '>' '=' )=>t1= '>' t2= '>' t3= '=' {...}? | ( '>' '>' '>' '=' )=>t1= '>' t2= '>' t3= '>' t4= '=' {...}? | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | LOR_ASSIGN | LAND_ASSIGN );
    public final ASCollectorParser.assignmentOperator_int_return assignmentOperator_int() throws RecognitionException {
        ASCollectorParser.assignmentOperator_int_return retval = new ASCollectorParser.assignmentOperator_int_return();
        retval.start = input.LT(1);
        int assignmentOperator_int_StartIndex = input.index();
        Object root_0 = null;

        Token s=null;
        Token a=null;
        Token t1=null;
        Token t2=null;
        Token t3=null;
        Token t4=null;
        Token ASSIGN221=null;
        Token DIV_ASSIGN222=null;
        Token MOD_ASSIGN223=null;
        Token ADD_ASSIGN224=null;
        Token SUB_ASSIGN225=null;
        Token SHL_ASSIGN226=null;
        Token AND_ASSIGN227=null;
        Token XOR_ASSIGN228=null;
        Token OR_ASSIGN229=null;
        Token LOR_ASSIGN230=null;
        Token LAND_ASSIGN231=null;

        Object s_tree=null;
        Object a_tree=null;
        Object t1_tree=null;
        Object t2_tree=null;
        Object t3_tree=null;
        Object t4_tree=null;
        Object ASSIGN221_tree=null;
        Object DIV_ASSIGN222_tree=null;
        Object MOD_ASSIGN223_tree=null;
        Object ADD_ASSIGN224_tree=null;
        Object SUB_ASSIGN225_tree=null;
        Object SHL_ASSIGN226_tree=null;
        Object AND_ASSIGN227_tree=null;
        Object XOR_ASSIGN228_tree=null;
        Object OR_ASSIGN229_tree=null;
        Object LOR_ASSIGN230_tree=null;
        Object LAND_ASSIGN231_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return retval; }
            // ASCollector.g3:2174:5: ( ASSIGN | s= STAR a= ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | ( '>' '>' '=' )=>t1= '>' t2= '>' t3= '=' {...}? | ( '>' '>' '>' '=' )=>t1= '>' t2= '>' t3= '>' t4= '=' {...}? | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | LOR_ASSIGN | LAND_ASSIGN )
            int alt122=14;
            alt122 = dfa122.predict(input);
            switch (alt122) {
                case 1 :
                    // ASCollector.g3:2174:7: ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    ASSIGN221=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentOperator_int10817); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    ASSIGN221_tree = (Object)adaptor.create(ASSIGN221);
                    adaptor.addChild(root_0, ASSIGN221_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2176:4: s= STAR a= ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    s=(Token)match(input,STAR,FOLLOW_STAR_in_assignmentOperator_int10826); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    s_tree = (Object)adaptor.create(s);
                    adaptor.addChild(root_0, s_tree);
                    }
                    a=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentOperator_int10830); if (state.failed) return retval;

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2177:7: DIV_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    DIV_ASSIGN222=(Token)match(input,DIV_ASSIGN,FOLLOW_DIV_ASSIGN_in_assignmentOperator_int10840); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    DIV_ASSIGN222_tree = (Object)adaptor.create(DIV_ASSIGN222);
                    adaptor.addChild(root_0, DIV_ASSIGN222_tree);
                    }

                    }
                    break;
                case 4 :
                    // ASCollector.g3:2178:7: MOD_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    MOD_ASSIGN223=(Token)match(input,MOD_ASSIGN,FOLLOW_MOD_ASSIGN_in_assignmentOperator_int10849); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    MOD_ASSIGN223_tree = (Object)adaptor.create(MOD_ASSIGN223);
                    adaptor.addChild(root_0, MOD_ASSIGN223_tree);
                    }

                    }
                    break;
                case 5 :
                    // ASCollector.g3:2179:7: ADD_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    ADD_ASSIGN224=(Token)match(input,ADD_ASSIGN,FOLLOW_ADD_ASSIGN_in_assignmentOperator_int10858); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    ADD_ASSIGN224_tree = (Object)adaptor.create(ADD_ASSIGN224);
                    adaptor.addChild(root_0, ADD_ASSIGN224_tree);
                    }

                    }
                    break;
                case 6 :
                    // ASCollector.g3:2180:7: SUB_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    SUB_ASSIGN225=(Token)match(input,SUB_ASSIGN,FOLLOW_SUB_ASSIGN_in_assignmentOperator_int10867); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    SUB_ASSIGN225_tree = (Object)adaptor.create(SUB_ASSIGN225);
                    adaptor.addChild(root_0, SUB_ASSIGN225_tree);
                    }

                    }
                    break;
                case 7 :
                    // ASCollector.g3:2181:7: SHL_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    SHL_ASSIGN226=(Token)match(input,SHL_ASSIGN,FOLLOW_SHL_ASSIGN_in_assignmentOperator_int10875); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    SHL_ASSIGN226_tree = (Object)adaptor.create(SHL_ASSIGN226);
                    adaptor.addChild(root_0, SHL_ASSIGN226_tree);
                    }

                    }
                    break;
                case 8 :
                    // ASCollector.g3:2192:5: ( '>' '>' '=' )=>t1= '>' t2= '>' t3= '=' {...}?
                    {
                    root_0 = (Object)adaptor.nil();

                    t1=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator_int10910); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t1_tree = (Object)adaptor.create(t1);
                    adaptor.addChild(root_0, t1_tree);
                    }
                    t2=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator_int10914); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t2_tree = (Object)adaptor.create(t2);
                    adaptor.addChild(root_0, t2_tree);
                    }
                    t3=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentOperator_int10918); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t3_tree = (Object)adaptor.create(t3);
                    adaptor.addChild(root_0, t3_tree);
                    }
                    if ( !(( t1.getLine() == t2.getLine() && 
                              t1.getCharPositionInLine() + 1 == t2.getCharPositionInLine() && 
                              t2.getLine() == t3.getLine() && 
                              t2.getCharPositionInLine() + 1 == t3.getCharPositionInLine() )) ) {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        throw new FailedPredicateException(input, "assignmentOperator_int", " $t1.getLine() == $t2.getLine() && \r\n          $t1.getCharPositionInLine() + 1 == $t2.getCharPositionInLine() && \r\n          $t2.getLine() == $t3.getLine() && \r\n          $t2.getCharPositionInLine() + 1 == $t3.getCharPositionInLine() ");
                    }
                    if ( state.backtracking==0 ) {
                      t1.setText(">>=");
                    }

                    }
                    break;
                case 9 :
                    // ASCollector.g3:2202:5: ( '>' '>' '>' '=' )=>t1= '>' t2= '>' t3= '>' t4= '=' {...}?
                    {
                    root_0 = (Object)adaptor.nil();

                    t1=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator_int10975); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t1_tree = (Object)adaptor.create(t1);
                    adaptor.addChild(root_0, t1_tree);
                    }
                    t2=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator_int10979); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t2_tree = (Object)adaptor.create(t2);
                    adaptor.addChild(root_0, t2_tree);
                    }
                    t3=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator_int10983); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t3_tree = (Object)adaptor.create(t3);
                    adaptor.addChild(root_0, t3_tree);
                    }
                    t4=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentOperator_int10987); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    t4_tree = (Object)adaptor.create(t4);
                    adaptor.addChild(root_0, t4_tree);
                    }
                    if ( !(( t1.getLine() == t2.getLine() && 
                              t1.getCharPositionInLine() + 1 == t2.getCharPositionInLine() &&
                              t2.getLine() == t3.getLine() && 
                              t2.getCharPositionInLine() + 1 == t3.getCharPositionInLine() &&
                              t3.getLine() == t4.getLine() && 
                              t3.getCharPositionInLine() + 1 == t4.getCharPositionInLine() )) ) {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        throw new FailedPredicateException(input, "assignmentOperator_int", " $t1.getLine() == $t2.getLine() && \r\n          $t1.getCharPositionInLine() + 1 == $t2.getCharPositionInLine() &&\r\n          $t2.getLine() == $t3.getLine() && \r\n          $t2.getCharPositionInLine() + 1 == $t3.getCharPositionInLine() &&\r\n          $t3.getLine() == $t4.getLine() && \r\n          $t3.getCharPositionInLine() + 1 == $t4.getCharPositionInLine() ");
                    }
                    if ( state.backtracking==0 ) {
                      t1.setText(">>>=");
                    }

                    }
                    break;
                case 10 :
                    // ASCollector.g3:2211:7: AND_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    AND_ASSIGN227=(Token)match(input,AND_ASSIGN,FOLLOW_AND_ASSIGN_in_assignmentOperator_int11020); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    AND_ASSIGN227_tree = (Object)adaptor.create(AND_ASSIGN227);
                    adaptor.addChild(root_0, AND_ASSIGN227_tree);
                    }

                    }
                    break;
                case 11 :
                    // ASCollector.g3:2212:7: XOR_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    XOR_ASSIGN228=(Token)match(input,XOR_ASSIGN,FOLLOW_XOR_ASSIGN_in_assignmentOperator_int11029); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    XOR_ASSIGN228_tree = (Object)adaptor.create(XOR_ASSIGN228);
                    adaptor.addChild(root_0, XOR_ASSIGN228_tree);
                    }

                    }
                    break;
                case 12 :
                    // ASCollector.g3:2213:7: OR_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    OR_ASSIGN229=(Token)match(input,OR_ASSIGN,FOLLOW_OR_ASSIGN_in_assignmentOperator_int11038); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    OR_ASSIGN229_tree = (Object)adaptor.create(OR_ASSIGN229);
                    adaptor.addChild(root_0, OR_ASSIGN229_tree);
                    }

                    }
                    break;
                case 13 :
                    // ASCollector.g3:2214:7: LOR_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    LOR_ASSIGN230=(Token)match(input,LOR_ASSIGN,FOLLOW_LOR_ASSIGN_in_assignmentOperator_int11046); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    LOR_ASSIGN230_tree = (Object)adaptor.create(LOR_ASSIGN230);
                    adaptor.addChild(root_0, LOR_ASSIGN230_tree);
                    }

                    }
                    break;
                case 14 :
                    // ASCollector.g3:2215:7: LAND_ASSIGN
                    {
                    root_0 = (Object)adaptor.nil();

                    LAND_ASSIGN231=(Token)match(input,LAND_ASSIGN,FOLLOW_LAND_ASSIGN_in_assignmentOperator_int11054); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    LAND_ASSIGN231_tree = (Object)adaptor.create(LAND_ASSIGN231);
                    adaptor.addChild(root_0, LAND_ASSIGN231_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 105, assignmentOperator_int_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "assignmentOperator_int"

    public static class conditionalExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalExpression"
    // ASCollector.g3:2219:1: conditionalExpression : logicalORExpression (Q= QUE assignmentExpression C= COLON assignmentExpression )? ;
    public final ASCollectorParser.conditionalExpression_return conditionalExpression() throws RecognitionException {
        ASCollectorParser.conditionalExpression_return retval = new ASCollectorParser.conditionalExpression_return();
        retval.start = input.LT(1);
        int conditionalExpression_StartIndex = input.index();
        Object root_0 = null;

        Token Q=null;
        Token C=null;
        ASCollectorParser.logicalORExpression_return logicalORExpression232 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression233 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression234 = null;


        Object Q_tree=null;
        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return retval; }
            // ASCollector.g3:2220:5: ( logicalORExpression (Q= QUE assignmentExpression C= COLON assignmentExpression )? )
            // ASCollector.g3:2220:9: logicalORExpression (Q= QUE assignmentExpression C= COLON assignmentExpression )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_logicalORExpression_in_conditionalExpression11074);
            logicalORExpression232=logicalORExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalORExpression232.getTree());
            // ASCollector.g3:2220:29: (Q= QUE assignmentExpression C= COLON assignmentExpression )?
            int alt123=2;
            int LA123_0 = input.LA(1);

            if ( (LA123_0==QUE) ) {
                int LA123_1 = input.LA(2);

                if ( (synpred254_ASCollector()) ) {
                    alt123=1;
                }
            }
            switch (alt123) {
                case 1 :
                    // ASCollector.g3:2220:31: Q= QUE assignmentExpression C= COLON assignmentExpression
                    {
                    Q=(Token)match(input,QUE,FOLLOW_QUE_in_conditionalExpression11080); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    Q_tree = (Object)adaptor.create(Q);
                    adaptor.addChild(root_0, Q_tree);
                    }
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpression11084);
                    assignmentExpression233=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression233.getTree());
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_conditionalExpression11090); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpression11094);
                    assignmentExpression234=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression234.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 106, conditionalExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "conditionalExpression"

    public static class conditionalExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalExpressionNoIn"
    // ASCollector.g3:2223:1: conditionalExpressionNoIn : logicalORExpressionNoIn (Q= QUE assignmentExpression C= COLON assignmentExpression )? ;
    public final ASCollectorParser.conditionalExpressionNoIn_return conditionalExpressionNoIn() throws RecognitionException {
        ASCollectorParser.conditionalExpressionNoIn_return retval = new ASCollectorParser.conditionalExpressionNoIn_return();
        retval.start = input.LT(1);
        int conditionalExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token Q=null;
        Token C=null;
        ASCollectorParser.logicalORExpressionNoIn_return logicalORExpressionNoIn235 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression236 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression237 = null;


        Object Q_tree=null;
        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return retval; }
            // ASCollector.g3:2224:5: ( logicalORExpressionNoIn (Q= QUE assignmentExpression C= COLON assignmentExpression )? )
            // ASCollector.g3:2224:9: logicalORExpressionNoIn (Q= QUE assignmentExpression C= COLON assignmentExpression )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_logicalORExpressionNoIn_in_conditionalExpressionNoIn11120);
            logicalORExpressionNoIn235=logicalORExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalORExpressionNoIn235.getTree());
            // ASCollector.g3:2224:33: (Q= QUE assignmentExpression C= COLON assignmentExpression )?
            int alt124=2;
            int LA124_0 = input.LA(1);

            if ( (LA124_0==QUE) ) {
                alt124=1;
            }
            switch (alt124) {
                case 1 :
                    // ASCollector.g3:2224:35: Q= QUE assignmentExpression C= COLON assignmentExpression
                    {
                    Q=(Token)match(input,QUE,FOLLOW_QUE_in_conditionalExpressionNoIn11126); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    Q_tree = (Object)adaptor.create(Q);
                    adaptor.addChild(root_0, Q_tree);
                    }
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpressionNoIn11129);
                    assignmentExpression236=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression236.getTree());
                    C=(Token)match(input,COLON,FOLLOW_COLON_in_conditionalExpressionNoIn11135); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpressionNoIn11139);
                    assignmentExpression237=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression237.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 107, conditionalExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "conditionalExpressionNoIn"

    public static class logicalORExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "logicalORExpression"
    // ASCollector.g3:2228:1: logicalORExpression : logicalANDExpression (L= LOR logicalANDExpression )* ;
    public final ASCollectorParser.logicalORExpression_return logicalORExpression() throws RecognitionException {
        ASCollectorParser.logicalORExpression_return retval = new ASCollectorParser.logicalORExpression_return();
        retval.start = input.LT(1);
        int logicalORExpression_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        ASCollectorParser.logicalANDExpression_return logicalANDExpression238 = null;

        ASCollectorParser.logicalANDExpression_return logicalANDExpression239 = null;


        Object L_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return retval; }
            // ASCollector.g3:2229:5: ( logicalANDExpression (L= LOR logicalANDExpression )* )
            // ASCollector.g3:2229:9: logicalANDExpression (L= LOR logicalANDExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_logicalANDExpression_in_logicalORExpression11170);
            logicalANDExpression238=logicalANDExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalANDExpression238.getTree());
            // ASCollector.g3:2229:30: (L= LOR logicalANDExpression )*
            loop125:
            do {
                int alt125=2;
                int LA125_0 = input.LA(1);

                if ( (LA125_0==LOR) ) {
                    int LA125_2 = input.LA(2);

                    if ( (synpred256_ASCollector()) ) {
                        alt125=1;
                    }


                }


                switch (alt125) {
            	case 1 :
            	    // ASCollector.g3:2229:32: L= LOR logicalANDExpression
            	    {
            	    L=(Token)match(input,LOR,FOLLOW_LOR_in_logicalORExpression11176); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    L_tree = (Object)adaptor.create(L);
            	    adaptor.addChild(root_0, L_tree);
            	    }
            	    pushFollow(FOLLOW_logicalANDExpression_in_logicalORExpression11179);
            	    logicalANDExpression239=logicalANDExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalANDExpression239.getTree());

            	    }
            	    break;

            	default :
            	    break loop125;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 108, logicalORExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "logicalORExpression"

    public static class logicalORExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "logicalORExpressionNoIn"
    // ASCollector.g3:2232:1: logicalORExpressionNoIn : logicalANDExpressionNoIn (L= LOR logicalANDExpressionNoIn )* ;
    public final ASCollectorParser.logicalORExpressionNoIn_return logicalORExpressionNoIn() throws RecognitionException {
        ASCollectorParser.logicalORExpressionNoIn_return retval = new ASCollectorParser.logicalORExpressionNoIn_return();
        retval.start = input.LT(1);
        int logicalORExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        ASCollectorParser.logicalANDExpressionNoIn_return logicalANDExpressionNoIn240 = null;

        ASCollectorParser.logicalANDExpressionNoIn_return logicalANDExpressionNoIn241 = null;


        Object L_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return retval; }
            // ASCollector.g3:2233:5: ( logicalANDExpressionNoIn (L= LOR logicalANDExpressionNoIn )* )
            // ASCollector.g3:2233:9: logicalANDExpressionNoIn (L= LOR logicalANDExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn11206);
            logicalANDExpressionNoIn240=logicalANDExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalANDExpressionNoIn240.getTree());
            // ASCollector.g3:2233:34: (L= LOR logicalANDExpressionNoIn )*
            loop126:
            do {
                int alt126=2;
                int LA126_0 = input.LA(1);

                if ( (LA126_0==LOR) ) {
                    alt126=1;
                }


                switch (alt126) {
            	case 1 :
            	    // ASCollector.g3:2233:36: L= LOR logicalANDExpressionNoIn
            	    {
            	    L=(Token)match(input,LOR,FOLLOW_LOR_in_logicalORExpressionNoIn11212); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    L_tree = (Object)adaptor.create(L);
            	    adaptor.addChild(root_0, L_tree);
            	    }
            	    pushFollow(FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn11215);
            	    logicalANDExpressionNoIn241=logicalANDExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, logicalANDExpressionNoIn241.getTree());

            	    }
            	    break;

            	default :
            	    break loop126;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 109, logicalORExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "logicalORExpressionNoIn"

    public static class logicalANDExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "logicalANDExpression"
    // ASCollector.g3:2236:1: logicalANDExpression : bitwiseORExpression (L= LAND bitwiseORExpression )* ;
    public final ASCollectorParser.logicalANDExpression_return logicalANDExpression() throws RecognitionException {
        ASCollectorParser.logicalANDExpression_return retval = new ASCollectorParser.logicalANDExpression_return();
        retval.start = input.LT(1);
        int logicalANDExpression_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        ASCollectorParser.bitwiseORExpression_return bitwiseORExpression242 = null;

        ASCollectorParser.bitwiseORExpression_return bitwiseORExpression243 = null;


        Object L_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return retval; }
            // ASCollector.g3:2237:5: ( bitwiseORExpression (L= LAND bitwiseORExpression )* )
            // ASCollector.g3:2237:9: bitwiseORExpression (L= LAND bitwiseORExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_bitwiseORExpression_in_logicalANDExpression11246);
            bitwiseORExpression242=bitwiseORExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseORExpression242.getTree());
            // ASCollector.g3:2237:29: (L= LAND bitwiseORExpression )*
            loop127:
            do {
                int alt127=2;
                int LA127_0 = input.LA(1);

                if ( (LA127_0==LAND) ) {
                    int LA127_2 = input.LA(2);

                    if ( (synpred258_ASCollector()) ) {
                        alt127=1;
                    }


                }


                switch (alt127) {
            	case 1 :
            	    // ASCollector.g3:2237:31: L= LAND bitwiseORExpression
            	    {
            	    L=(Token)match(input,LAND,FOLLOW_LAND_in_logicalANDExpression11252); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    L_tree = (Object)adaptor.create(L);
            	    adaptor.addChild(root_0, L_tree);
            	    }
            	    pushFollow(FOLLOW_bitwiseORExpression_in_logicalANDExpression11255);
            	    bitwiseORExpression243=bitwiseORExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseORExpression243.getTree());

            	    }
            	    break;

            	default :
            	    break loop127;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 110, logicalANDExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "logicalANDExpression"

    public static class logicalANDExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "logicalANDExpressionNoIn"
    // ASCollector.g3:2240:1: logicalANDExpressionNoIn : bitwiseORExpressionNoIn (L= LAND bitwiseORExpressionNoIn )* ;
    public final ASCollectorParser.logicalANDExpressionNoIn_return logicalANDExpressionNoIn() throws RecognitionException {
        ASCollectorParser.logicalANDExpressionNoIn_return retval = new ASCollectorParser.logicalANDExpressionNoIn_return();
        retval.start = input.LT(1);
        int logicalANDExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        ASCollectorParser.bitwiseORExpressionNoIn_return bitwiseORExpressionNoIn244 = null;

        ASCollectorParser.bitwiseORExpressionNoIn_return bitwiseORExpressionNoIn245 = null;


        Object L_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 111) ) { return retval; }
            // ASCollector.g3:2241:5: ( bitwiseORExpressionNoIn (L= LAND bitwiseORExpressionNoIn )* )
            // ASCollector.g3:2241:9: bitwiseORExpressionNoIn (L= LAND bitwiseORExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn11281);
            bitwiseORExpressionNoIn244=bitwiseORExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseORExpressionNoIn244.getTree());
            // ASCollector.g3:2241:33: (L= LAND bitwiseORExpressionNoIn )*
            loop128:
            do {
                int alt128=2;
                int LA128_0 = input.LA(1);

                if ( (LA128_0==LAND) ) {
                    alt128=1;
                }


                switch (alt128) {
            	case 1 :
            	    // ASCollector.g3:2241:35: L= LAND bitwiseORExpressionNoIn
            	    {
            	    L=(Token)match(input,LAND,FOLLOW_LAND_in_logicalANDExpressionNoIn11287); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    L_tree = (Object)adaptor.create(L);
            	    adaptor.addChild(root_0, L_tree);
            	    }
            	    pushFollow(FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn11290);
            	    bitwiseORExpressionNoIn245=bitwiseORExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseORExpressionNoIn245.getTree());

            	    }
            	    break;

            	default :
            	    break loop128;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 111, logicalANDExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "logicalANDExpressionNoIn"

    public static class bitwiseORExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bitwiseORExpression"
    // ASCollector.g3:2245:1: bitwiseORExpression : bitwiseXORExpression (O= OR bitwiseXORExpression )* ;
    public final ASCollectorParser.bitwiseORExpression_return bitwiseORExpression() throws RecognitionException {
        ASCollectorParser.bitwiseORExpression_return retval = new ASCollectorParser.bitwiseORExpression_return();
        retval.start = input.LT(1);
        int bitwiseORExpression_StartIndex = input.index();
        Object root_0 = null;

        Token O=null;
        ASCollectorParser.bitwiseXORExpression_return bitwiseXORExpression246 = null;

        ASCollectorParser.bitwiseXORExpression_return bitwiseXORExpression247 = null;


        Object O_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 112) ) { return retval; }
            // ASCollector.g3:2246:5: ( bitwiseXORExpression (O= OR bitwiseXORExpression )* )
            // ASCollector.g3:2246:9: bitwiseXORExpression (O= OR bitwiseXORExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_bitwiseXORExpression_in_bitwiseORExpression11321);
            bitwiseXORExpression246=bitwiseXORExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseXORExpression246.getTree());
            // ASCollector.g3:2246:30: (O= OR bitwiseXORExpression )*
            loop129:
            do {
                int alt129=2;
                int LA129_0 = input.LA(1);

                if ( (LA129_0==OR) ) {
                    int LA129_2 = input.LA(2);

                    if ( (synpred260_ASCollector()) ) {
                        alt129=1;
                    }


                }


                switch (alt129) {
            	case 1 :
            	    // ASCollector.g3:2246:32: O= OR bitwiseXORExpression
            	    {
            	    O=(Token)match(input,OR,FOLLOW_OR_in_bitwiseORExpression11327); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    O_tree = (Object)adaptor.create(O);
            	    adaptor.addChild(root_0, O_tree);
            	    }
            	    pushFollow(FOLLOW_bitwiseXORExpression_in_bitwiseORExpression11330);
            	    bitwiseXORExpression247=bitwiseXORExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseXORExpression247.getTree());

            	    }
            	    break;

            	default :
            	    break loop129;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 112, bitwiseORExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bitwiseORExpression"

    public static class bitwiseORExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bitwiseORExpressionNoIn"
    // ASCollector.g3:2249:1: bitwiseORExpressionNoIn : bitwiseXORExpressionNoIn (O= OR bitwiseXORExpressionNoIn )* ;
    public final ASCollectorParser.bitwiseORExpressionNoIn_return bitwiseORExpressionNoIn() throws RecognitionException {
        ASCollectorParser.bitwiseORExpressionNoIn_return retval = new ASCollectorParser.bitwiseORExpressionNoIn_return();
        retval.start = input.LT(1);
        int bitwiseORExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token O=null;
        ASCollectorParser.bitwiseXORExpressionNoIn_return bitwiseXORExpressionNoIn248 = null;

        ASCollectorParser.bitwiseXORExpressionNoIn_return bitwiseXORExpressionNoIn249 = null;


        Object O_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 113) ) { return retval; }
            // ASCollector.g3:2250:5: ( bitwiseXORExpressionNoIn (O= OR bitwiseXORExpressionNoIn )* )
            // ASCollector.g3:2250:9: bitwiseXORExpressionNoIn (O= OR bitwiseXORExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn11356);
            bitwiseXORExpressionNoIn248=bitwiseXORExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseXORExpressionNoIn248.getTree());
            // ASCollector.g3:2250:34: (O= OR bitwiseXORExpressionNoIn )*
            loop130:
            do {
                int alt130=2;
                int LA130_0 = input.LA(1);

                if ( (LA130_0==OR) ) {
                    alt130=1;
                }


                switch (alt130) {
            	case 1 :
            	    // ASCollector.g3:2250:36: O= OR bitwiseXORExpressionNoIn
            	    {
            	    O=(Token)match(input,OR,FOLLOW_OR_in_bitwiseORExpressionNoIn11362); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    O_tree = (Object)adaptor.create(O);
            	    adaptor.addChild(root_0, O_tree);
            	    }
            	    pushFollow(FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn11365);
            	    bitwiseXORExpressionNoIn249=bitwiseXORExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseXORExpressionNoIn249.getTree());

            	    }
            	    break;

            	default :
            	    break loop130;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 113, bitwiseORExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bitwiseORExpressionNoIn"

    public static class bitwiseXORExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bitwiseXORExpression"
    // ASCollector.g3:2253:1: bitwiseXORExpression : bitwiseANDExpression (x= XOR bitwiseANDExpression )* ;
    public final ASCollectorParser.bitwiseXORExpression_return bitwiseXORExpression() throws RecognitionException {
        ASCollectorParser.bitwiseXORExpression_return retval = new ASCollectorParser.bitwiseXORExpression_return();
        retval.start = input.LT(1);
        int bitwiseXORExpression_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;
        ASCollectorParser.bitwiseANDExpression_return bitwiseANDExpression250 = null;

        ASCollectorParser.bitwiseANDExpression_return bitwiseANDExpression251 = null;


        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 114) ) { return retval; }
            // ASCollector.g3:2254:5: ( bitwiseANDExpression (x= XOR bitwiseANDExpression )* )
            // ASCollector.g3:2254:9: bitwiseANDExpression (x= XOR bitwiseANDExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression11395);
            bitwiseANDExpression250=bitwiseANDExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseANDExpression250.getTree());
            // ASCollector.g3:2254:30: (x= XOR bitwiseANDExpression )*
            loop131:
            do {
                int alt131=2;
                int LA131_0 = input.LA(1);

                if ( (LA131_0==XOR) ) {
                    int LA131_2 = input.LA(2);

                    if ( (synpred262_ASCollector()) ) {
                        alt131=1;
                    }


                }


                switch (alt131) {
            	case 1 :
            	    // ASCollector.g3:2254:32: x= XOR bitwiseANDExpression
            	    {
            	    x=(Token)match(input,XOR,FOLLOW_XOR_in_bitwiseXORExpression11401); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    x_tree = (Object)adaptor.create(x);
            	    adaptor.addChild(root_0, x_tree);
            	    }
            	    pushFollow(FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression11404);
            	    bitwiseANDExpression251=bitwiseANDExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseANDExpression251.getTree());

            	    }
            	    break;

            	default :
            	    break loop131;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 114, bitwiseXORExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bitwiseXORExpression"

    public static class bitwiseXORExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bitwiseXORExpressionNoIn"
    // ASCollector.g3:2257:1: bitwiseXORExpressionNoIn : bitwiseANDExpressionNoIn (x= XOR bitwiseANDExpressionNoIn )* ;
    public final ASCollectorParser.bitwiseXORExpressionNoIn_return bitwiseXORExpressionNoIn() throws RecognitionException {
        ASCollectorParser.bitwiseXORExpressionNoIn_return retval = new ASCollectorParser.bitwiseXORExpressionNoIn_return();
        retval.start = input.LT(1);
        int bitwiseXORExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token x=null;
        ASCollectorParser.bitwiseANDExpressionNoIn_return bitwiseANDExpressionNoIn252 = null;

        ASCollectorParser.bitwiseANDExpressionNoIn_return bitwiseANDExpressionNoIn253 = null;


        Object x_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 115) ) { return retval; }
            // ASCollector.g3:2258:5: ( bitwiseANDExpressionNoIn (x= XOR bitwiseANDExpressionNoIn )* )
            // ASCollector.g3:2258:9: bitwiseANDExpressionNoIn (x= XOR bitwiseANDExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn11430);
            bitwiseANDExpressionNoIn252=bitwiseANDExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseANDExpressionNoIn252.getTree());
            // ASCollector.g3:2258:34: (x= XOR bitwiseANDExpressionNoIn )*
            loop132:
            do {
                int alt132=2;
                int LA132_0 = input.LA(1);

                if ( (LA132_0==XOR) ) {
                    alt132=1;
                }


                switch (alt132) {
            	case 1 :
            	    // ASCollector.g3:2258:36: x= XOR bitwiseANDExpressionNoIn
            	    {
            	    x=(Token)match(input,XOR,FOLLOW_XOR_in_bitwiseXORExpressionNoIn11436); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    x_tree = (Object)adaptor.create(x);
            	    adaptor.addChild(root_0, x_tree);
            	    }
            	    pushFollow(FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn11439);
            	    bitwiseANDExpressionNoIn253=bitwiseANDExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, bitwiseANDExpressionNoIn253.getTree());

            	    }
            	    break;

            	default :
            	    break loop132;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 115, bitwiseXORExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bitwiseXORExpressionNoIn"

    public static class bitwiseANDExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bitwiseANDExpression"
    // ASCollector.g3:2261:1: bitwiseANDExpression : equalityExpression (A= AND equalityExpression )* ;
    public final ASCollectorParser.bitwiseANDExpression_return bitwiseANDExpression() throws RecognitionException {
        ASCollectorParser.bitwiseANDExpression_return retval = new ASCollectorParser.bitwiseANDExpression_return();
        retval.start = input.LT(1);
        int bitwiseANDExpression_StartIndex = input.index();
        Object root_0 = null;

        Token A=null;
        ASCollectorParser.equalityExpression_return equalityExpression254 = null;

        ASCollectorParser.equalityExpression_return equalityExpression255 = null;


        Object A_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 116) ) { return retval; }
            // ASCollector.g3:2262:5: ( equalityExpression (A= AND equalityExpression )* )
            // ASCollector.g3:2262:9: equalityExpression (A= AND equalityExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_equalityExpression_in_bitwiseANDExpression11465);
            equalityExpression254=equalityExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, equalityExpression254.getTree());
            // ASCollector.g3:2262:28: (A= AND equalityExpression )*
            loop133:
            do {
                int alt133=2;
                int LA133_0 = input.LA(1);

                if ( (LA133_0==AND) ) {
                    int LA133_2 = input.LA(2);

                    if ( (synpred264_ASCollector()) ) {
                        alt133=1;
                    }


                }


                switch (alt133) {
            	case 1 :
            	    // ASCollector.g3:2262:30: A= AND equalityExpression
            	    {
            	    A=(Token)match(input,AND,FOLLOW_AND_in_bitwiseANDExpression11471); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    A_tree = (Object)adaptor.create(A);
            	    adaptor.addChild(root_0, A_tree);
            	    }
            	    pushFollow(FOLLOW_equalityExpression_in_bitwiseANDExpression11474);
            	    equalityExpression255=equalityExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, equalityExpression255.getTree());

            	    }
            	    break;

            	default :
            	    break loop133;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 116, bitwiseANDExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bitwiseANDExpression"

    public static class bitwiseANDExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "bitwiseANDExpressionNoIn"
    // ASCollector.g3:2265:1: bitwiseANDExpressionNoIn : equalityExpressionNoIn (A= AND equalityExpressionNoIn )* ;
    public final ASCollectorParser.bitwiseANDExpressionNoIn_return bitwiseANDExpressionNoIn() throws RecognitionException {
        ASCollectorParser.bitwiseANDExpressionNoIn_return retval = new ASCollectorParser.bitwiseANDExpressionNoIn_return();
        retval.start = input.LT(1);
        int bitwiseANDExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token A=null;
        ASCollectorParser.equalityExpressionNoIn_return equalityExpressionNoIn256 = null;

        ASCollectorParser.equalityExpressionNoIn_return equalityExpressionNoIn257 = null;


        Object A_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 117) ) { return retval; }
            // ASCollector.g3:2266:5: ( equalityExpressionNoIn (A= AND equalityExpressionNoIn )* )
            // ASCollector.g3:2266:9: equalityExpressionNoIn (A= AND equalityExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn11500);
            equalityExpressionNoIn256=equalityExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, equalityExpressionNoIn256.getTree());
            // ASCollector.g3:2266:32: (A= AND equalityExpressionNoIn )*
            loop134:
            do {
                int alt134=2;
                int LA134_0 = input.LA(1);

                if ( (LA134_0==AND) ) {
                    alt134=1;
                }


                switch (alt134) {
            	case 1 :
            	    // ASCollector.g3:2266:34: A= AND equalityExpressionNoIn
            	    {
            	    A=(Token)match(input,AND,FOLLOW_AND_in_bitwiseANDExpressionNoIn11506); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    A_tree = (Object)adaptor.create(A);
            	    adaptor.addChild(root_0, A_tree);
            	    }
            	    pushFollow(FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn11509);
            	    equalityExpressionNoIn257=equalityExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, equalityExpressionNoIn257.getTree());

            	    }
            	    break;

            	default :
            	    break loop134;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 117, bitwiseANDExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "bitwiseANDExpressionNoIn"

    public static class equalityExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "equalityExpression"
    // ASCollector.g3:2270:1: equalityExpression : relationalExpression (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression )* ;
    public final ASCollectorParser.equalityExpression_return equalityExpression() throws RecognitionException {
        ASCollectorParser.equalityExpression_return retval = new ASCollectorParser.equalityExpression_return();
        retval.start = input.LT(1);
        int equalityExpression_StartIndex = input.index();
        Object root_0 = null;

        Token eq=null;
        ASCollectorParser.relationalExpression_return relationalExpression258 = null;

        ASCollectorParser.relationalExpression_return relationalExpression259 = null;


        Object eq_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 118) ) { return retval; }
            // ASCollector.g3:2271:5: ( relationalExpression (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression )* )
            // ASCollector.g3:2271:9: relationalExpression (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_relationalExpression_in_equalityExpression11536);
            relationalExpression258=relationalExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalExpression258.getTree());
            // ASCollector.g3:2271:30: (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression )*
            loop135:
            do {
                int alt135=2;
                int LA135_0 = input.LA(1);

                if ( ((LA135_0>=EQ && LA135_0<=NSAME)) ) {
                    int LA135_2 = input.LA(2);

                    if ( (synpred269_ASCollector()) ) {
                        alt135=1;
                    }


                }


                switch (alt135) {
            	case 1 :
            	    // ASCollector.g3:2271:32: eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression
            	    {
            	    eq=(Token)input.LT(1);
            	    if ( (input.LA(1)>=EQ && input.LA(1)<=NSAME) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(eq));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	    pushFollow(FOLLOW_relationalExpression_in_equalityExpression11553);
            	    relationalExpression259=relationalExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalExpression259.getTree());

            	    }
            	    break;

            	default :
            	    break loop135;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 118, equalityExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "equalityExpression"

    public static class equalityExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "equalityExpressionNoIn"
    // ASCollector.g3:2274:1: equalityExpressionNoIn : relationalExpressionNoIn (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpressionNoIn )* ;
    public final ASCollectorParser.equalityExpressionNoIn_return equalityExpressionNoIn() throws RecognitionException {
        ASCollectorParser.equalityExpressionNoIn_return retval = new ASCollectorParser.equalityExpressionNoIn_return();
        retval.start = input.LT(1);
        int equalityExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token eq=null;
        ASCollectorParser.relationalExpressionNoIn_return relationalExpressionNoIn260 = null;

        ASCollectorParser.relationalExpressionNoIn_return relationalExpressionNoIn261 = null;


        Object eq_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 119) ) { return retval; }
            // ASCollector.g3:2275:5: ( relationalExpressionNoIn (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpressionNoIn )* )
            // ASCollector.g3:2275:9: relationalExpressionNoIn (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpressionNoIn )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn11579);
            relationalExpressionNoIn260=relationalExpressionNoIn();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalExpressionNoIn260.getTree());
            // ASCollector.g3:2275:34: (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpressionNoIn )*
            loop136:
            do {
                int alt136=2;
                int LA136_0 = input.LA(1);

                if ( ((LA136_0>=EQ && LA136_0<=NSAME)) ) {
                    alt136=1;
                }


                switch (alt136) {
            	case 1 :
            	    // ASCollector.g3:2275:36: eq= ( EQ | NEQ | SAME | NSAME ) relationalExpressionNoIn
            	    {
            	    eq=(Token)input.LT(1);
            	    if ( (input.LA(1)>=EQ && input.LA(1)<=NSAME) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(eq));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	    pushFollow(FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn11597);
            	    relationalExpressionNoIn261=relationalExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalExpressionNoIn261.getTree());

            	    }
            	    break;

            	default :
            	    break loop136;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 119, equalityExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "equalityExpressionNoIn"

    public static class relationalExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "relationalExpression"
    // ASCollector.g3:2279:1: relationalExpression : shiftExpression ( (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )* ;
    public final ASCollectorParser.relationalExpression_return relationalExpression() throws RecognitionException {
        ASCollectorParser.relationalExpression_return retval = new ASCollectorParser.relationalExpression_return();
        retval.start = input.LT(1);
        int relationalExpression_StartIndex = input.index();
        Object root_0 = null;

        Token g=null;
        Token assign=null;
        Token eq=null;
        ASCollectorParser.shiftExpression_return shiftExpression262 = null;

        ASCollectorParser.shiftExpression_return shiftExpression263 = null;


        Object g_tree=null;
        Object assign_tree=null;
        Object eq_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 120) ) { return retval; }
            // ASCollector.g3:2280:5: ( shiftExpression ( (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )* )
            // ASCollector.g3:2280:9: shiftExpression ( (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_shiftExpression_in_relationalExpression11624);
            shiftExpression262=shiftExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression262.getTree());
            // ASCollector.g3:2281:6: ( (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )*
            loop139:
            do {
                int alt139=2;
                alt139 = dfa139.predict(input);
                switch (alt139) {
            	case 1 :
            	    // ASCollector.g3:2282:7: (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression
            	    {
            	    // ASCollector.g3:2282:7: (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) )
            	    int alt138=2;
            	    int LA138_0 = input.LA(1);

            	    if ( (LA138_0==GT) ) {
            	        alt138=1;
            	    }
            	    else if ( (LA138_0==AS||(LA138_0>=IN && LA138_0<=INSTANCEOF)||LA138_0==IS||LA138_0==LT||LA138_0==LTE) ) {
            	        alt138=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 138, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt138) {
            	        case 1 :
            	            // ASCollector.g3:2282:9: g= GT (assign= ASSIGN )?
            	            {
            	            g=(Token)match(input,GT,FOLLOW_GT_in_relationalExpression11644); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            g_tree = (Object)adaptor.create(g);
            	            adaptor.addChild(root_0, g_tree);
            	            }
            	            // ASCollector.g3:2282:14: (assign= ASSIGN )?
            	            int alt137=2;
            	            int LA137_0 = input.LA(1);

            	            if ( (LA137_0==ASSIGN) ) {
            	                alt137=1;
            	            }
            	            switch (alt137) {
            	                case 1 :
            	                    // ASCollector.g3:2282:15: assign= ASSIGN
            	                    {
            	                    assign=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_relationalExpression11649); if (state.failed) return retval;
            	                    if ( state.backtracking==0 ) {
            	                    assign_tree = (Object)adaptor.create(assign);
            	                    adaptor.addChild(root_0, assign_tree);
            	                    }

            	                    }
            	                    break;

            	            }

            	            if ( state.backtracking==0 ) {
            	              if (assign!=null)
            	              		         {
            	              		         	g.setText(">=");
            	              		         	g.setType(GTE);
            	              		         }
            	              		        
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // ASCollector.g3:2289:14: eq= ( IN | LT | LTE | INSTANCEOF | IS | AS )
            	            {
            	            eq=(Token)input.LT(1);
            	            if ( input.LA(1)==AS||(input.LA(1)>=IN && input.LA(1)<=INSTANCEOF)||input.LA(1)==IS||input.LA(1)==LT||input.LA(1)==LTE ) {
            	                input.consume();
            	                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(eq));
            	                state.errorRecovery=false;state.failed=false;
            	            }
            	            else {
            	                if (state.backtracking>0) {state.failed=true; return retval;}
            	                MismatchedSetException mse = new MismatchedSetException(null,input);
            	                throw mse;
            	            }


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_shiftExpression_in_relationalExpression11719);
            	    shiftExpression263=shiftExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression263.getTree());

            	    }
            	    break;

            	default :
            	    break loop139;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 120, relationalExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "relationalExpression"

    public static class relationalExpressionNoIn_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "relationalExpressionNoIn"
    // ASCollector.g3:2295:1: relationalExpressionNoIn : shiftExpression ( (g= GT (assign= ASSIGN )? | eq= ( LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )* ;
    public final ASCollectorParser.relationalExpressionNoIn_return relationalExpressionNoIn() throws RecognitionException {
        ASCollectorParser.relationalExpressionNoIn_return retval = new ASCollectorParser.relationalExpressionNoIn_return();
        retval.start = input.LT(1);
        int relationalExpressionNoIn_StartIndex = input.index();
        Object root_0 = null;

        Token g=null;
        Token assign=null;
        Token eq=null;
        ASCollectorParser.shiftExpression_return shiftExpression264 = null;

        ASCollectorParser.shiftExpression_return shiftExpression265 = null;


        Object g_tree=null;
        Object assign_tree=null;
        Object eq_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 121) ) { return retval; }
            // ASCollector.g3:2296:5: ( shiftExpression ( (g= GT (assign= ASSIGN )? | eq= ( LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )* )
            // ASCollector.g3:2296:9: shiftExpression ( (g= GT (assign= ASSIGN )? | eq= ( LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_shiftExpression_in_relationalExpressionNoIn11754);
            shiftExpression264=shiftExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression264.getTree());
            // ASCollector.g3:2297:6: ( (g= GT (assign= ASSIGN )? | eq= ( LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )*
            loop142:
            do {
                int alt142=2;
                int LA142_0 = input.LA(1);

                if ( (LA142_0==AS||LA142_0==INSTANCEOF||LA142_0==IS||(LA142_0>=LT && LA142_0<=LTE)) ) {
                    alt142=1;
                }


                switch (alt142) {
            	case 1 :
            	    // ASCollector.g3:2298:7: (g= GT (assign= ASSIGN )? | eq= ( LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression
            	    {
            	    // ASCollector.g3:2298:7: (g= GT (assign= ASSIGN )? | eq= ( LT | LTE | INSTANCEOF | IS | AS ) )
            	    int alt141=2;
            	    int LA141_0 = input.LA(1);

            	    if ( (LA141_0==GT) ) {
            	        alt141=1;
            	    }
            	    else if ( (LA141_0==AS||LA141_0==INSTANCEOF||LA141_0==IS||LA141_0==LT||LA141_0==LTE) ) {
            	        alt141=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 141, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt141) {
            	        case 1 :
            	            // ASCollector.g3:2298:9: g= GT (assign= ASSIGN )?
            	            {
            	            g=(Token)match(input,GT,FOLLOW_GT_in_relationalExpressionNoIn11774); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            g_tree = (Object)adaptor.create(g);
            	            adaptor.addChild(root_0, g_tree);
            	            }
            	            // ASCollector.g3:2298:14: (assign= ASSIGN )?
            	            int alt140=2;
            	            int LA140_0 = input.LA(1);

            	            if ( (LA140_0==ASSIGN) ) {
            	                alt140=1;
            	            }
            	            switch (alt140) {
            	                case 1 :
            	                    // ASCollector.g3:2298:15: assign= ASSIGN
            	                    {
            	                    assign=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_relationalExpressionNoIn11779); if (state.failed) return retval;
            	                    if ( state.backtracking==0 ) {
            	                    assign_tree = (Object)adaptor.create(assign);
            	                    adaptor.addChild(root_0, assign_tree);
            	                    }

            	                    }
            	                    break;

            	            }

            	            if ( state.backtracking==0 ) {
            	              if (assign!=null)
            	              		         {
            	              		         	g.setText(">=");
            	              		         	g.setType(GTE);
            	              		         }
            	              		        
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // ASCollector.g3:2305:14: eq= ( LT | LTE | INSTANCEOF | IS | AS )
            	            {
            	            eq=(Token)input.LT(1);
            	            if ( input.LA(1)==AS||input.LA(1)==INSTANCEOF||input.LA(1)==IS||input.LA(1)==LT||input.LA(1)==LTE ) {
            	                input.consume();
            	                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(eq));
            	                state.errorRecovery=false;state.failed=false;
            	            }
            	            else {
            	                if (state.backtracking>0) {state.failed=true; return retval;}
            	                MismatchedSetException mse = new MismatchedSetException(null,input);
            	                throw mse;
            	            }


            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_shiftExpression_in_relationalExpressionNoIn11847);
            	    shiftExpression265=shiftExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression265.getTree());

            	    }
            	    break;

            	default :
            	    break loop142;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 121, relationalExpressionNoIn_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "relationalExpressionNoIn"

    public static class shiftExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "shiftExpression"
    // ASCollector.g3:2312:1: shiftExpression : a= additiveExpression ( (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression )* ;
    public final ASCollectorParser.shiftExpression_return shiftExpression() throws RecognitionException {
        ASCollectorParser.shiftExpression_return retval = new ASCollectorParser.shiftExpression_return();
        retval.start = input.LT(1);
        int shiftExpression_StartIndex = input.index();
        Object root_0 = null;

        Token t1=null;
        Token t2=null;
        Token t3=null;
        ASCollectorParser.additiveExpression_return a = null;

        ASCollectorParser.additiveExpression_return a1 = null;


        Object t1_tree=null;
        Object t2_tree=null;
        Object t3_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 122) ) { return retval; }
            // ASCollector.g3:2313:5: (a= additiveExpression ( (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression )* )
            // ASCollector.g3:2313:9: a= additiveExpression ( (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_additiveExpression_in_shiftExpression11881);
            a=additiveExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, a.getTree());
            // ASCollector.g3:2313:30: ( (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression )*
            loop144:
            do {
                int alt144=2;
                int LA144_0 = input.LA(1);

                if ( (LA144_0==GT) ) {
                    int LA144_1 = input.LA(2);

                    if ( (synpred292_ASCollector()) ) {
                        alt144=1;
                    }


                }
                else if ( (LA144_0==SHL) ) {
                    int LA144_3 = input.LA(2);

                    if ( (synpred292_ASCollector()) ) {
                        alt144=1;
                    }


                }


                switch (alt144) {
            	case 1 :
            	    // ASCollector.g3:2314:7: (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression
            	    {
            	    // ASCollector.g3:2314:7: (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?)
            	    int alt143=3;
            	    alt143 = dfa143.predict(input);
            	    switch (alt143) {
            	        case 1 :
            	            // ASCollector.g3:2315:8: t1= SHL
            	            {
            	            t1=(Token)match(input,SHL,FOLLOW_SHL_in_shiftExpression11903); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            t1_tree = (Object)adaptor.create(t1);
            	            adaptor.addChild(root_0, t1_tree);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // ASCollector.g3:2322:9: ( '>' '>' )=>t1= '>' t2= '>' {...}?
            	            {
            	            t1=(Token)match(input,GT,FOLLOW_GT_in_shiftExpression11951); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            t1_tree = (Object)adaptor.create(t1);
            	            adaptor.addChild(root_0, t1_tree);
            	            }
            	            t2=(Token)match(input,GT,FOLLOW_GT_in_shiftExpression11955); if (state.failed) return retval;
            	            if ( !(( t1.getLine() == t2.getLine() && 
            	                      			t1.getCharPositionInLine() + 1 == t2.getCharPositionInLine() )) ) {
            	                if (state.backtracking>0) {state.failed=true; return retval;}
            	                throw new FailedPredicateException(input, "shiftExpression", " $t1.getLine() == $t2.getLine() && \r\n          \t\t\t$t1.getCharPositionInLine() + 1 == $t2.getCharPositionInLine() ");
            	            }
            	            if ( state.backtracking==0 ) {
            	              t1.setText(">>");
            	            }

            	            }
            	            break;
            	        case 3 :
            	            // ASCollector.g3:2329:7: ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?
            	            {
            	            t1=(Token)match(input,GT,FOLLOW_GT_in_shiftExpression12016); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            t1_tree = (Object)adaptor.create(t1);
            	            adaptor.addChild(root_0, t1_tree);
            	            }
            	            t2=(Token)match(input,GT,FOLLOW_GT_in_shiftExpression12020); if (state.failed) return retval;
            	            t3=(Token)match(input,GT,FOLLOW_GT_in_shiftExpression12025); if (state.failed) return retval;
            	            if ( !(( t1.getLine() == t2.getLine() && 
            	                      			t1.getCharPositionInLine() + 1 == t2.getCharPositionInLine() &&
            	                      			t2.getLine() == t3.getLine() && 
            	                      			t2.getCharPositionInLine() + 1 == t3.getCharPositionInLine() )) ) {
            	                if (state.backtracking>0) {state.failed=true; return retval;}
            	                throw new FailedPredicateException(input, "shiftExpression", " $t1.getLine() == $t2.getLine() && \r\n          \t\t\t$t1.getCharPositionInLine() + 1 == $t2.getCharPositionInLine() &&\r\n          \t\t\t$t2.getLine() == $t3.getLine() && \r\n          \t\t\t$t2.getCharPositionInLine() + 1 == $t3.getCharPositionInLine() ");
            	            }
            	            if ( state.backtracking==0 ) {
            	              t1.setText(">>>");
            	            }

            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_additiveExpression_in_shiftExpression12078);
            	    a1=additiveExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, a1.getTree());

            	    }
            	    break;

            	default :
            	    break loop144;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 122, shiftExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "shiftExpression"

    public static class additiveExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "additiveExpression"
    // ASCollector.g3:2342:1: additiveExpression : multiplicativeExpression (op= ( PLUS | SUB ) multiplicativeExpression )* ;
    public final ASCollectorParser.additiveExpression_return additiveExpression() throws RecognitionException {
        ASCollectorParser.additiveExpression_return retval = new ASCollectorParser.additiveExpression_return();
        retval.start = input.LT(1);
        int additiveExpression_StartIndex = input.index();
        Object root_0 = null;

        Token op=null;
        ASCollectorParser.multiplicativeExpression_return multiplicativeExpression266 = null;

        ASCollectorParser.multiplicativeExpression_return multiplicativeExpression267 = null;


        Object op_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 123) ) { return retval; }
            // ASCollector.g3:2343:5: ( multiplicativeExpression (op= ( PLUS | SUB ) multiplicativeExpression )* )
            // ASCollector.g3:2343:9: multiplicativeExpression (op= ( PLUS | SUB ) multiplicativeExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression12107);
            multiplicativeExpression266=multiplicativeExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicativeExpression266.getTree());
            // ASCollector.g3:2343:34: (op= ( PLUS | SUB ) multiplicativeExpression )*
            loop145:
            do {
                int alt145=2;
                int LA145_0 = input.LA(1);

                if ( ((LA145_0>=PLUS && LA145_0<=SUB)) ) {
                    int LA145_2 = input.LA(2);

                    if ( (synpred294_ASCollector()) ) {
                        alt145=1;
                    }


                }


                switch (alt145) {
            	case 1 :
            	    // ASCollector.g3:2343:36: op= ( PLUS | SUB ) multiplicativeExpression
            	    {
            	    op=(Token)input.LT(1);
            	    if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(op));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression12120);
            	    multiplicativeExpression267=multiplicativeExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicativeExpression267.getTree());

            	    }
            	    break;

            	default :
            	    break loop145;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 123, additiveExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "additiveExpression"

    public static class multiplicativeExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "multiplicativeExpression"
    // ASCollector.g3:2347:1: multiplicativeExpression : unaryExpression (op= ( STAR | DIV | MOD ) unaryExpression )* ;
    public final ASCollectorParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
        ASCollectorParser.multiplicativeExpression_return retval = new ASCollectorParser.multiplicativeExpression_return();
        retval.start = input.LT(1);
        int multiplicativeExpression_StartIndex = input.index();
        Object root_0 = null;

        Token op=null;
        ASCollectorParser.unaryExpression_return unaryExpression268 = null;

        ASCollectorParser.unaryExpression_return unaryExpression269 = null;


        Object op_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 124) ) { return retval; }
            // ASCollector.g3:2348:5: ( unaryExpression (op= ( STAR | DIV | MOD ) unaryExpression )* )
            // ASCollector.g3:2348:9: unaryExpression (op= ( STAR | DIV | MOD ) unaryExpression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression12143);
            unaryExpression268=unaryExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression268.getTree());
            // ASCollector.g3:2348:25: (op= ( STAR | DIV | MOD ) unaryExpression )*
            loop146:
            do {
                int alt146=2;
                int LA146_0 = input.LA(1);

                if ( (LA146_0==STAR) ) {
                    int LA146_2 = input.LA(2);

                    if ( (synpred297_ASCollector()) ) {
                        alt146=1;
                    }


                }
                else if ( ((LA146_0>=DIV && LA146_0<=MOD)) ) {
                    int LA146_3 = input.LA(2);

                    if ( (synpred297_ASCollector()) ) {
                        alt146=1;
                    }


                }


                switch (alt146) {
            	case 1 :
            	    // ASCollector.g3:2348:27: op= ( STAR | DIV | MOD ) unaryExpression
            	    {
            	    op=(Token)input.LT(1);
            	    if ( (input.LA(1)>=STAR && input.LA(1)<=MOD) ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(op));
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }

            	    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression12157);
            	    unaryExpression269=unaryExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression269.getTree());

            	    }
            	    break;

            	default :
            	    break loop146;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 124, multiplicativeExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"

    public static class unaryExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unaryExpression"
    // ASCollector.g3:2352:1: unaryExpression : ( postfixExpression | op= ( NOT | INV ) unaryExpression | unaryOp postfixExpression );
    public final ASCollectorParser.unaryExpression_return unaryExpression() throws RecognitionException {
        ASCollectorParser.unaryExpression_return retval = new ASCollectorParser.unaryExpression_return();
        retval.start = input.LT(1);
        int unaryExpression_StartIndex = input.index();
        Object root_0 = null;

        Token op=null;
        ASCollectorParser.postfixExpression_return postfixExpression270 = null;

        ASCollectorParser.unaryExpression_return unaryExpression271 = null;

        ASCollectorParser.unaryOp_return unaryOp272 = null;

        ASCollectorParser.postfixExpression_return postfixExpression273 = null;


        Object op_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 125) ) { return retval; }
            // ASCollector.g3:2353:5: ( postfixExpression | op= ( NOT | INV ) unaryExpression | unaryOp postfixExpression )
            int alt147=3;
            alt147 = dfa147.predict(input);
            switch (alt147) {
                case 1 :
                    // ASCollector.g3:2353:9: postfixExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_postfixExpression_in_unaryExpression12180);
                    postfixExpression270=postfixExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixExpression270.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2354:8: op= ( NOT | INV ) unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    op=(Token)input.LT(1);
                    if ( (input.LA(1)>=NOT && input.LA(1)<=INV) ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(op));
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression12200);
                    unaryExpression271=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression271.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2355:9: unaryOp postfixExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_unaryOp_in_unaryExpression12210);
                    unaryOp272=unaryOp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryOp272.getTree());
                    pushFollow(FOLLOW_postfixExpression_in_unaryExpression12212);
                    postfixExpression273=postfixExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixExpression273.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 125, unaryExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "unaryExpression"

    public static class unaryOp_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unaryOp"
    // ASCollector.g3:2360:1: unaryOp : op= ( DELETE | VOID | TYPEOF | INC | DEC | PLUS | SUB | INV | NOT ) ;
    public final ASCollectorParser.unaryOp_return unaryOp() throws RecognitionException {
        ASCollectorParser.unaryOp_return retval = new ASCollectorParser.unaryOp_return();
        retval.start = input.LT(1);
        int unaryOp_StartIndex = input.index();
        Object root_0 = null;

        Token op=null;

        Object op_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 126) ) { return retval; }
            // ASCollector.g3:2361:5: (op= ( DELETE | VOID | TYPEOF | INC | DEC | PLUS | SUB | INV | NOT ) )
            // ASCollector.g3:2361:9: op= ( DELETE | VOID | TYPEOF | INC | DEC | PLUS | SUB | INV | NOT )
            {
            root_0 = (Object)adaptor.nil();

            op=(Token)input.LT(1);
            if ( input.LA(1)==DELETE||input.LA(1)==TYPEOF||input.LA(1)==VOID||(input.LA(1)>=PLUS && input.LA(1)<=SUB)||(input.LA(1)>=INC && input.LA(1)<=DEC)||(input.LA(1)>=NOT && input.LA(1)<=INV) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(op));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 126, unaryOp_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "unaryOp"

    public static class postfixExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "postfixExpression"
    // ASCollector.g3:2366:1: postfixExpression : leftHandSideExpression ( postfixOp )? ;
    public final ASCollectorParser.postfixExpression_return postfixExpression() throws RecognitionException {
        ASCollectorParser.postfixExpression_return retval = new ASCollectorParser.postfixExpression_return();
        retval.start = input.LT(1);
        int postfixExpression_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.leftHandSideExpression_return leftHandSideExpression274 = null;

        ASCollectorParser.postfixOp_return postfixOp275 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 127) ) { return retval; }
            // ASCollector.g3:2367:5: ( leftHandSideExpression ( postfixOp )? )
            // ASCollector.g3:2367:9: leftHandSideExpression ( postfixOp )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_leftHandSideExpression_in_postfixExpression12299);
            leftHandSideExpression274=leftHandSideExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, leftHandSideExpression274.getTree());
            // ASCollector.g3:2367:32: ( postfixOp )?
            int alt148=2;
            int LA148_0 = input.LA(1);

            if ( ((LA148_0>=INC && LA148_0<=DEC)) ) {
                int LA148_1 = input.LA(2);

                if ( (synpred309_ASCollector()) ) {
                    alt148=1;
                }
            }
            switch (alt148) {
                case 1 :
                    // ASCollector.g3:0:0: postfixOp
                    {
                    pushFollow(FOLLOW_postfixOp_in_postfixExpression12301);
                    postfixOp275=postfixOp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, postfixOp275.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 127, postfixExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "postfixExpression"

    public static class postfixOp_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "postfixOp"
    // ASCollector.g3:2370:1: postfixOp : op= ( INC | DEC ) ;
    public final ASCollectorParser.postfixOp_return postfixOp() throws RecognitionException {
        ASCollectorParser.postfixOp_return retval = new ASCollectorParser.postfixOp_return();
        retval.start = input.LT(1);
        int postfixOp_StartIndex = input.index();
        Object root_0 = null;

        Token op=null;

        Object op_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 128) ) { return retval; }
            // ASCollector.g3:2371:5: (op= ( INC | DEC ) )
            // ASCollector.g3:2371:9: op= ( INC | DEC )
            {
            root_0 = (Object)adaptor.nil();

            op=(Token)input.LT(1);
            if ( (input.LA(1)>=INC && input.LA(1)<=DEC) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(op));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 128, postfixOp_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "postfixOp"

    public static class memberExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "memberExpression"
    // ASCollector.g3:2375:1: memberExpression : (p= primaryExpression | f= functionExpression | n= newExpression );
    public final ASCollectorParser.memberExpression_return memberExpression() throws RecognitionException {
        ASCollectorParser.memberExpression_return retval = new ASCollectorParser.memberExpression_return();
        retval.start = input.LT(1);
        int memberExpression_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.primaryExpression_return p = null;

        ASCollectorParser.functionExpression_return f = null;

        ASCollectorParser.newExpression_return n = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 129) ) { return retval; }
            // ASCollector.g3:2376:2: (p= primaryExpression | f= functionExpression | n= newExpression )
            int alt149=3;
            switch ( input.LA(1) ) {
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NATIVE:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TO:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case INCLUDE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case LCURLY:
            case LPAREN:
            case LBRACK:
            case LT:
            case STAR:
            case XML_AT:
            case XML_LS_STD:
            case SINGLE_QUOTE_LITERAL:
            case DOUBLE_QUOTE_LITERAL:
            case REGULAR_EXPR_LITERAL:
            case HEX_NUMBER_LITERAL:
            case DEC_NUMBER_LITERAL:
            case IDENTIFIER:
            case XML_COMMENT:
            case XML_CDATA:
            case XML_PI:
                {
                alt149=1;
                }
                break;
            case FUNCTION:
                {
                int LA149_2 = input.LA(2);

                if ( (LA149_2==DOT||LA149_2==SUB||LA149_2==COLON||LA149_2==XML_NS_OP) ) {
                    alt149=1;
                }
                else if ( (LA149_2==LPAREN||LA149_2==IDENTIFIER) ) {
                    alt149=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 149, 2, input);

                    throw nvae;
                }
                }
                break;
            case NEW:
                {
                int LA149_3 = input.LA(2);

                if ( ((LA149_3>=AS && LA149_3<=STATIC)||LA149_3==LCURLY||LA149_3==LPAREN||LA149_3==LBRACK||LA149_3==LT||LA149_3==STAR||(LA149_3>=XML_AT && LA149_3<=XML_LS_STD)||(LA149_3>=SINGLE_QUOTE_LITERAL && LA149_3<=DOUBLE_QUOTE_LITERAL)||LA149_3==REGULAR_EXPR_LITERAL||LA149_3==HEX_NUMBER_LITERAL||LA149_3==DEC_NUMBER_LITERAL||LA149_3==IDENTIFIER||(LA149_3>=XML_COMMENT && LA149_3<=XML_PI)) ) {
                    alt149=3;
                }
                else if ( (LA149_3==DOT||LA149_3==SUB||LA149_3==COLON||LA149_3==XML_NS_OP) ) {
                    alt149=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 149, 3, input);

                    throw nvae;
                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 149, 0, input);

                throw nvae;
            }

            switch (alt149) {
                case 1 :
                    // ASCollector.g3:2376:4: p= primaryExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_primaryExpression_in_memberExpression12350);
                    p=primaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, p.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2377:4: f= functionExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_functionExpression_in_memberExpression12357);
                    f=functionExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, f.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2378:4: n= newExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_newExpression_in_memberExpression12364);
                    n=newExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, n.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 129, memberExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "memberExpression"

    public static class newExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "newExpression"
    // ASCollector.g3:2381:1: newExpression : N= NEW p= primaryExpression ;
    public final ASCollectorParser.newExpression_return newExpression() throws RecognitionException {
        ASCollectorParser.newExpression_return retval = new ASCollectorParser.newExpression_return();
        retval.start = input.LT(1);
        int newExpression_StartIndex = input.index();
        Object root_0 = null;

        Token N=null;
        ASCollectorParser.primaryExpression_return p = null;


        Object N_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 130) ) { return retval; }
            // ASCollector.g3:2382:2: (N= NEW p= primaryExpression )
            // ASCollector.g3:2382:4: N= NEW p= primaryExpression
            {
            root_0 = (Object)adaptor.nil();

            N=(Token)match(input,NEW,FOLLOW_NEW_in_newExpression12377); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            N_tree = (Object)adaptor.create(N);
            adaptor.addChild(root_0, N_tree);
            }
            pushFollow(FOLLOW_primaryExpression_in_newExpression12383);
            p=primaryExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, p.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 130, newExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "newExpression"

    public static class leftHandSideExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "leftHandSideExpression"
    // ASCollector.g3:2386:1: leftHandSideExpression : m= memberExpression ( arguments | L= LBRACK expression R= RBRACK | XML_ELLIPSIS eitherIdentifier | DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | XML_NS_OP expression )* ;
    public final ASCollectorParser.leftHandSideExpression_return leftHandSideExpression() throws RecognitionException {
        ASCollectorParser.leftHandSideExpression_return retval = new ASCollectorParser.leftHandSideExpression_return();
        retval.start = input.LT(1);
        int leftHandSideExpression_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        Token XML_ELLIPSIS278=null;
        Token DOT280=null;
        Token XML_NS_OP284=null;
        ASCollectorParser.memberExpression_return m = null;

        ASCollectorParser.arguments_return arguments276 = null;

        ASCollectorParser.expression_return expression277 = null;

        ASCollectorParser.eitherIdentifier_return eitherIdentifier279 = null;

        ASCollectorParser.eitherIdentifier_return eitherIdentifier281 = null;

        ASCollectorParser.parExpression_return parExpression282 = null;

        ASCollectorParser.typePostfixSyntax_return typePostfixSyntax283 = null;

        ASCollectorParser.expression_return expression285 = null;


        Object L_tree=null;
        Object R_tree=null;
        Object XML_ELLIPSIS278_tree=null;
        Object DOT280_tree=null;
        Object XML_NS_OP284_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 131) ) { return retval; }
            // ASCollector.g3:2387:5: (m= memberExpression ( arguments | L= LBRACK expression R= RBRACK | XML_ELLIPSIS eitherIdentifier | DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | XML_NS_OP expression )* )
            // ASCollector.g3:2387:9: m= memberExpression ( arguments | L= LBRACK expression R= RBRACK | XML_ELLIPSIS eitherIdentifier | DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | XML_NS_OP expression )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_memberExpression_in_leftHandSideExpression12402);
            m=memberExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, m.getTree());
            // ASCollector.g3:2388:5: ( arguments | L= LBRACK expression R= RBRACK | XML_ELLIPSIS eitherIdentifier | DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | XML_NS_OP expression )*
            loop151:
            do {
                int alt151=7;
                alt151 = dfa151.predict(input);
                switch (alt151) {
            	case 1 :
            	    // ASCollector.g3:2389:7: arguments
            	    {
            	    pushFollow(FOLLOW_arguments_in_leftHandSideExpression12417);
            	    arguments276=arguments();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments276.getTree());

            	    }
            	    break;
            	case 2 :
            	    // ASCollector.g3:2390:9: L= LBRACK expression R= RBRACK
            	    {
            	    L=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_leftHandSideExpression12429); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    L_tree = (Object)adaptor.create(L);
            	    adaptor.addChild(root_0, L_tree);
            	    }
            	    pushFollow(FOLLOW_expression_in_leftHandSideExpression12432);
            	    expression277=expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression277.getTree());
            	    R=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_leftHandSideExpression12436); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    R_tree = (Object)adaptor.create(R);
            	    adaptor.addChild(root_0, R_tree);
            	    }

            	    }
            	    break;
            	case 3 :
            	    // ASCollector.g3:2393:9: XML_ELLIPSIS eitherIdentifier
            	    {
            	    XML_ELLIPSIS278=(Token)match(input,XML_ELLIPSIS,FOLLOW_XML_ELLIPSIS_in_leftHandSideExpression12449); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    XML_ELLIPSIS278_tree = (Object)adaptor.create(XML_ELLIPSIS278);
            	    adaptor.addChild(root_0, XML_ELLIPSIS278_tree);
            	    }
            	    pushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression12451);
            	    eitherIdentifier279=eitherIdentifier();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, eitherIdentifier279.getTree());

            	    }
            	    break;
            	case 4 :
            	    // ASCollector.g3:2394:9: DOT ( eitherIdentifier | parExpression )
            	    {
            	    DOT280=(Token)match(input,DOT,FOLLOW_DOT_in_leftHandSideExpression12461); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    DOT280_tree = (Object)adaptor.create(DOT280);
            	    adaptor.addChild(root_0, DOT280_tree);
            	    }
            	    // ASCollector.g3:2394:13: ( eitherIdentifier | parExpression )
            	    int alt150=2;
            	    int LA150_0 = input.LA(1);

            	    if ( ((LA150_0>=AS && LA150_0<=STATIC)||LA150_0==STAR||LA150_0==XML_AT||LA150_0==IDENTIFIER) ) {
            	        alt150=1;
            	    }
            	    else if ( (LA150_0==LPAREN) ) {
            	        alt150=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 150, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt150) {
            	        case 1 :
            	            // ASCollector.g3:2394:14: eitherIdentifier
            	            {
            	            pushFollow(FOLLOW_eitherIdentifier_in_leftHandSideExpression12464);
            	            eitherIdentifier281=eitherIdentifier();

            	            state._fsp--;
            	            if (state.failed) return retval;
            	            if ( state.backtracking==0 ) adaptor.addChild(root_0, eitherIdentifier281.getTree());

            	            }
            	            break;
            	        case 2 :
            	            // ASCollector.g3:2394:33: parExpression
            	            {
            	            pushFollow(FOLLOW_parExpression_in_leftHandSideExpression12468);
            	            parExpression282=parExpression();

            	            state._fsp--;
            	            if (state.failed) return retval;
            	            if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression282.getTree());

            	            }
            	            break;

            	    }


            	    }
            	    break;
            	case 5 :
            	    // ASCollector.g3:2395:9: typePostfixSyntax
            	    {
            	    pushFollow(FOLLOW_typePostfixSyntax_in_leftHandSideExpression12479);
            	    typePostfixSyntax283=typePostfixSyntax();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, typePostfixSyntax283.getTree());

            	    }
            	    break;
            	case 6 :
            	    // ASCollector.g3:2396:9: XML_NS_OP expression
            	    {
            	    XML_NS_OP284=(Token)match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_leftHandSideExpression12489); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    XML_NS_OP284_tree = (Object)adaptor.create(XML_NS_OP284);
            	    adaptor.addChild(root_0, XML_NS_OP284_tree);
            	    }
            	    pushFollow(FOLLOW_expression_in_leftHandSideExpression12491);
            	    expression285=expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression285.getTree());

            	    }
            	    break;

            	default :
            	    break loop151;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 131, leftHandSideExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "leftHandSideExpression"

    public static class eitherIdentifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "eitherIdentifier"
    // ASCollector.g3:2400:1: eitherIdentifier : (I= IDENTIFIER | xmlPropertyIdentifier | allKeywords );
    public final ASCollectorParser.eitherIdentifier_return eitherIdentifier() throws RecognitionException {
        ASCollectorParser.eitherIdentifier_return retval = new ASCollectorParser.eitherIdentifier_return();
        retval.start = input.LT(1);
        int eitherIdentifier_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        ASCollectorParser.xmlPropertyIdentifier_return xmlPropertyIdentifier286 = null;

        ASCollectorParser.allKeywords_return allKeywords287 = null;


        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 132) ) { return retval; }
            // ASCollector.g3:2401:2: (I= IDENTIFIER | xmlPropertyIdentifier | allKeywords )
            int alt152=3;
            switch ( input.LA(1) ) {
            case IDENTIFIER:
                {
                int LA152_1 = input.LA(2);

                if ( (synpred320_ASCollector()) ) {
                    alt152=1;
                }
                else if ( (synpred321_ASCollector()) ) {
                    alt152=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 152, 1, input);

                    throw nvae;
                }
                }
                break;
            case STAR:
            case XML_AT:
                {
                alt152=2;
                }
                break;
            case AS:
            case BREAK:
            case CASE:
            case CATCH:
            case CLASS:
            case CONST:
            case CONTINUE:
            case DEFAULT:
            case DELETE:
            case DO:
            case ELSE:
            case EXTENDS:
            case FALSE:
            case FINALLY:
            case FOR:
            case FUNCTION:
            case IF:
            case IMPLEMENTS:
            case IMPORT:
            case IN:
            case INSTANCEOF:
            case INTERFACE:
            case INTERNAL:
            case IS:
            case NEW:
            case NULL:
            case PACKAGE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case RETURN:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TRUE:
            case TRY:
            case TYPEOF:
            case USE:
            case VAR:
            case VOID:
            case WHILE:
            case WITH:
            case INCLUDE:
                {
                int LA152_3 = input.LA(2);

                if ( (synpred321_ASCollector()) ) {
                    alt152=2;
                }
                else if ( (true) ) {
                    alt152=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 152, 3, input);

                    throw nvae;
                }
                }
                break;
            case NATIVE:
            case TO:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
                {
                int LA152_4 = input.LA(2);

                if ( (synpred321_ASCollector()) ) {
                    alt152=2;
                }
                else if ( (true) ) {
                    alt152=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 152, 4, input);

                    throw nvae;
                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 152, 0, input);

                throw nvae;
            }

            switch (alt152) {
                case 1 :
                    // ASCollector.g3:2401:4: I= IDENTIFIER
                    {
                    root_0 = (Object)adaptor.nil();

                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_eitherIdentifier12520); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2402:5: xmlPropertyIdentifier
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlPropertyIdentifier_in_eitherIdentifier12529);
                    xmlPropertyIdentifier286=xmlPropertyIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPropertyIdentifier286.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2403:5: allKeywords
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_allKeywords_in_eitherIdentifier12535);
                    allKeywords287=allKeywords();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, allKeywords287.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 132, eitherIdentifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "eitherIdentifier"

    public static class typeSpecifier_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "typeSpecifier"
    // ASCollector.g3:2406:1: typeSpecifier : (I= IDENTIFIER | notQuiteReservedWord | I= INTERNAL | D= DEFAULT );
    public final ASCollectorParser.typeSpecifier_return typeSpecifier() throws RecognitionException {
        ASCollectorParser.typeSpecifier_return retval = new ASCollectorParser.typeSpecifier_return();
        retval.start = input.LT(1);
        int typeSpecifier_StartIndex = input.index();
        Object root_0 = null;

        Token I=null;
        Token D=null;
        ASCollectorParser.notQuiteReservedWord_return notQuiteReservedWord288 = null;


        Object I_tree=null;
        Object D_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 133) ) { return retval; }
            // ASCollector.g3:2406:14: (I= IDENTIFIER | notQuiteReservedWord | I= INTERNAL | D= DEFAULT )
            int alt153=4;
            switch ( input.LA(1) ) {
            case IDENTIFIER:
                {
                alt153=1;
                }
                break;
            case NATIVE:
            case TO:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
                {
                alt153=2;
                }
                break;
            case INTERNAL:
                {
                alt153=3;
                }
                break;
            case DEFAULT:
                {
                alt153=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 153, 0, input);

                throw nvae;
            }

            switch (alt153) {
                case 1 :
                    // ASCollector.g3:2407:2: I= IDENTIFIER
                    {
                    root_0 = (Object)adaptor.nil();

                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeSpecifier12548); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2407:18: notQuiteReservedWord
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_notQuiteReservedWord_in_typeSpecifier12553);
                    notQuiteReservedWord288=notQuiteReservedWord();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, notQuiteReservedWord288.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2407:41: I= INTERNAL
                    {
                    root_0 = (Object)adaptor.nil();

                    I=(Token)match(input,INTERNAL,FOLLOW_INTERNAL_in_typeSpecifier12559); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;
                case 4 :
                    // ASCollector.g3:2407:55: D= DEFAULT
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_typeSpecifier12566); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 133, typeSpecifier_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "typeSpecifier"

    public static class notQuiteReservedWord_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "notQuiteReservedWord"
    // ASCollector.g3:2411:1: notQuiteReservedWord : word= ( TO | NATIVE | EACH | GET | SET | NAMESPACE | DYNAMIC | FINAL | OVERRIDE | STATIC ) ;
    public final ASCollectorParser.notQuiteReservedWord_return notQuiteReservedWord() throws RecognitionException {
        ASCollectorParser.notQuiteReservedWord_return retval = new ASCollectorParser.notQuiteReservedWord_return();
        retval.start = input.LT(1);
        int notQuiteReservedWord_StartIndex = input.index();
        Object root_0 = null;

        Token word=null;

        Object word_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 134) ) { return retval; }
            // ASCollector.g3:2412:2: (word= ( TO | NATIVE | EACH | GET | SET | NAMESPACE | DYNAMIC | FINAL | OVERRIDE | STATIC ) )
            // ASCollector.g3:2413:2: word= ( TO | NATIVE | EACH | GET | SET | NAMESPACE | DYNAMIC | FINAL | OVERRIDE | STATIC )
            {
            root_0 = (Object)adaptor.nil();

            word=(Token)input.LT(1);
            if ( input.LA(1)==NATIVE||input.LA(1)==TO||(input.LA(1)>=EACH && input.LA(1)<=NAMESPACE)||(input.LA(1)>=DYNAMIC && input.LA(1)<=STATIC) ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(word));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 134, notQuiteReservedWord_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "notQuiteReservedWord"

    public static class allKeywords_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "allKeywords"
    // ASCollector.g3:2416:1: allKeywords : ( reservedWord | notQuiteReservedWord ) ;
    public final ASCollectorParser.allKeywords_return allKeywords() throws RecognitionException {
        ASCollectorParser.allKeywords_return retval = new ASCollectorParser.allKeywords_return();
        retval.start = input.LT(1);
        int allKeywords_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.reservedWord_return reservedWord289 = null;

        ASCollectorParser.notQuiteReservedWord_return notQuiteReservedWord290 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 135) ) { return retval; }
            // ASCollector.g3:2417:2: ( ( reservedWord | notQuiteReservedWord ) )
            // ASCollector.g3:2417:4: ( reservedWord | notQuiteReservedWord )
            {
            root_0 = (Object)adaptor.nil();

            // ASCollector.g3:2417:4: ( reservedWord | notQuiteReservedWord )
            int alt154=2;
            int LA154_0 = input.LA(1);

            if ( ((LA154_0>=AS && LA154_0<=IS)||(LA154_0>=NEW && LA154_0<=THROW)||(LA154_0>=TRUE && LA154_0<=WITH)||LA154_0==INCLUDE) ) {
                alt154=1;
            }
            else if ( (LA154_0==NATIVE||LA154_0==TO||(LA154_0>=EACH && LA154_0<=NAMESPACE)||(LA154_0>=DYNAMIC && LA154_0<=STATIC)) ) {
                alt154=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 154, 0, input);

                throw nvae;
            }
            switch (alt154) {
                case 1 :
                    // ASCollector.g3:2417:5: reservedWord
                    {
                    pushFollow(FOLLOW_reservedWord_in_allKeywords12636);
                    reservedWord289=reservedWord();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, reservedWord289.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2417:20: notQuiteReservedWord
                    {
                    pushFollow(FOLLOW_notQuiteReservedWord_in_allKeywords12640);
                    notQuiteReservedWord290=notQuiteReservedWord();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, notQuiteReservedWord290.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 135, allKeywords_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "allKeywords"

    public static class reservedWord_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "reservedWord"
    // ASCollector.g3:2419:1: reservedWord : word= ( AS | BREAK | CASE | CATCH | CLASS | CONST | CONTINUE | DEFAULT | DELETE | DO | ELSE | EXTENDS | FALSE | FINALLY | FOR | FUNCTION | IF | IMPLEMENTS | IMPORT | IN | INSTANCEOF | INTERFACE | INTERNAL | IS | NEW | NULL | PACKAGE | PRIVATE | PROTECTED | PUBLIC | RETURN | SUPER | SWITCH | THIS | THROW | TRUE | TRY | TYPEOF | USE | VAR | VOID | WHILE | WITH | INCLUDE ) ;
    public final ASCollectorParser.reservedWord_return reservedWord() throws RecognitionException {
        ASCollectorParser.reservedWord_return retval = new ASCollectorParser.reservedWord_return();
        retval.start = input.LT(1);
        int reservedWord_StartIndex = input.index();
        Object root_0 = null;

        Token word=null;

        Object word_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 136) ) { return retval; }
            // ASCollector.g3:2420:2: (word= ( AS | BREAK | CASE | CATCH | CLASS | CONST | CONTINUE | DEFAULT | DELETE | DO | ELSE | EXTENDS | FALSE | FINALLY | FOR | FUNCTION | IF | IMPLEMENTS | IMPORT | IN | INSTANCEOF | INTERFACE | INTERNAL | IS | NEW | NULL | PACKAGE | PRIVATE | PROTECTED | PUBLIC | RETURN | SUPER | SWITCH | THIS | THROW | TRUE | TRY | TYPEOF | USE | VAR | VOID | WHILE | WITH | INCLUDE ) )
            // ASCollector.g3:2421:5: word= ( AS | BREAK | CASE | CATCH | CLASS | CONST | CONTINUE | DEFAULT | DELETE | DO | ELSE | EXTENDS | FALSE | FINALLY | FOR | FUNCTION | IF | IMPLEMENTS | IMPORT | IN | INSTANCEOF | INTERFACE | INTERNAL | IS | NEW | NULL | PACKAGE | PRIVATE | PROTECTED | PUBLIC | RETURN | SUPER | SWITCH | THIS | THROW | TRUE | TRY | TYPEOF | USE | VAR | VOID | WHILE | WITH | INCLUDE )
            {
            root_0 = (Object)adaptor.nil();

            word=(Token)input.LT(1);
            if ( (input.LA(1)>=AS && input.LA(1)<=IS)||(input.LA(1)>=NEW && input.LA(1)<=THROW)||(input.LA(1)>=TRUE && input.LA(1)<=WITH)||input.LA(1)==INCLUDE ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(word));
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 136, reservedWord_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "reservedWord"

    public static class arguments_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "arguments"
    // ASCollector.g3:2478:1: arguments : L= LPAREN ( assignmentExpression (C= COMMA assignmentExpression )* )? R= RPAREN ;
    public final ASCollectorParser.arguments_return arguments() throws RecognitionException {
        ASCollectorParser.arguments_return retval = new ASCollectorParser.arguments_return();
        retval.start = input.LT(1);
        int arguments_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token C=null;
        Token R=null;
        ASCollectorParser.assignmentExpression_return assignmentExpression291 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression292 = null;


        Object L_tree=null;
        Object C_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 137) ) { return retval; }
            // ASCollector.g3:2479:2: (L= LPAREN ( assignmentExpression (C= COMMA assignmentExpression )* )? R= RPAREN )
            // ASCollector.g3:2481:4: L= LPAREN ( assignmentExpression (C= COMMA assignmentExpression )* )? R= RPAREN
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_arguments13214); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:2482:4: ( assignmentExpression (C= COMMA assignmentExpression )* )?
            int alt156=2;
            int LA156_0 = input.LA(1);

            if ( ((LA156_0>=AS && LA156_0<=STATIC)||LA156_0==LCURLY||LA156_0==LPAREN||LA156_0==LBRACK||LA156_0==LT||(LA156_0>=PLUS && LA156_0<=STAR)||(LA156_0>=INC && LA156_0<=DEC)||(LA156_0>=NOT && LA156_0<=INV)||(LA156_0>=XML_AT && LA156_0<=XML_LS_STD)||(LA156_0>=SINGLE_QUOTE_LITERAL && LA156_0<=DOUBLE_QUOTE_LITERAL)||LA156_0==REGULAR_EXPR_LITERAL||LA156_0==HEX_NUMBER_LITERAL||LA156_0==DEC_NUMBER_LITERAL||LA156_0==IDENTIFIER||(LA156_0>=XML_COMMENT && LA156_0<=XML_PI)) ) {
                alt156=1;
            }
            switch (alt156) {
                case 1 :
                    // ASCollector.g3:2482:7: assignmentExpression (C= COMMA assignmentExpression )*
                    {
                    pushFollow(FOLLOW_assignmentExpression_in_arguments13224);
                    assignmentExpression291=assignmentExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression291.getTree());
                    // ASCollector.g3:2483:10: (C= COMMA assignmentExpression )*
                    loop155:
                    do {
                        int alt155=2;
                        int LA155_0 = input.LA(1);

                        if ( (LA155_0==COMMA) ) {
                            alt155=1;
                        }


                        switch (alt155) {
                    	case 1 :
                    	    // ASCollector.g3:2484:11: C= COMMA assignmentExpression
                    	    {
                    	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_arguments13252); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    C_tree = (Object)adaptor.create(C);
                    	    adaptor.addChild(root_0, C_tree);
                    	    }
                    	    pushFollow(FOLLOW_assignmentExpression_in_arguments13276);
                    	    assignmentExpression292=assignmentExpression();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression292.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop155;
                        }
                    } while (true);


                    }
                    break;

            }

            R=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_arguments13304); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 137, arguments_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "arguments"

    public static class suffix_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "suffix"
    // ASCollector.g3:2496:1: suffix : ( indexSuffix | propertyReferenceSuffix );
    public final ASCollectorParser.suffix_return suffix() throws RecognitionException {
        ASCollectorParser.suffix_return retval = new ASCollectorParser.suffix_return();
        retval.start = input.LT(1);
        int suffix_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.indexSuffix_return indexSuffix293 = null;

        ASCollectorParser.propertyReferenceSuffix_return propertyReferenceSuffix294 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 138) ) { return retval; }
            // ASCollector.g3:2497:5: ( indexSuffix | propertyReferenceSuffix )
            int alt157=2;
            int LA157_0 = input.LA(1);

            if ( (LA157_0==LBRACK) ) {
                alt157=1;
            }
            else if ( (LA157_0==DOT) ) {
                alt157=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 157, 0, input);

                throw nvae;
            }
            switch (alt157) {
                case 1 :
                    // ASCollector.g3:2497:10: indexSuffix
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_indexSuffix_in_suffix13339);
                    indexSuffix293=indexSuffix();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, indexSuffix293.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2497:24: propertyReferenceSuffix
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_propertyReferenceSuffix_in_suffix13343);
                    propertyReferenceSuffix294=propertyReferenceSuffix();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyReferenceSuffix294.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 138, suffix_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "suffix"

    public static class indexSuffix_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "indexSuffix"
    // ASCollector.g3:2500:1: indexSuffix : L= LBRACK expression R= RBRACK ;
    public final ASCollectorParser.indexSuffix_return indexSuffix() throws RecognitionException {
        ASCollectorParser.indexSuffix_return retval = new ASCollectorParser.indexSuffix_return();
        retval.start = input.LT(1);
        int indexSuffix_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.expression_return expression295 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 139) ) { return retval; }
            // ASCollector.g3:2501:5: (L= LBRACK expression R= RBRACK )
            // ASCollector.g3:2501:10: L= LBRACK expression R= RBRACK
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_indexSuffix13378); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            pushFollow(FOLLOW_expression_in_indexSuffix13382);
            expression295=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression295.getTree());
            R=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_indexSuffix13387); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 139, indexSuffix_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "indexSuffix"

    public static class propertyReferenceSuffix_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "propertyReferenceSuffix"
    // ASCollector.g3:2504:1: propertyReferenceSuffix : (D= DOT I= IDENTIFIER | D= DOT xmlPropertyIdentifier | D= DOT );
    public final ASCollectorParser.propertyReferenceSuffix_return propertyReferenceSuffix() throws RecognitionException {
        ASCollectorParser.propertyReferenceSuffix_return retval = new ASCollectorParser.propertyReferenceSuffix_return();
        retval.start = input.LT(1);
        int propertyReferenceSuffix_StartIndex = input.index();
        Object root_0 = null;

        Token D=null;
        Token I=null;
        ASCollectorParser.xmlPropertyIdentifier_return xmlPropertyIdentifier296 = null;


        Object D_tree=null;
        Object I_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 140) ) { return retval; }
            // ASCollector.g3:2505:5: (D= DOT I= IDENTIFIER | D= DOT xmlPropertyIdentifier | D= DOT )
            int alt158=3;
            int LA158_0 = input.LA(1);

            if ( (LA158_0==DOT) ) {
                switch ( input.LA(2) ) {
                case IDENTIFIER:
                    {
                    int LA158_2 = input.LA(3);

                    if ( (LA158_2==EOF) ) {
                        alt158=1;
                    }
                    else if ( (LA158_2==DOT||LA158_2==SUB||LA158_2==COLON||LA158_2==XML_NS_OP) ) {
                        alt158=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 158, 2, input);

                        throw nvae;
                    }
                    }
                    break;
                case AS:
                case BREAK:
                case CASE:
                case CATCH:
                case CLASS:
                case CONST:
                case CONTINUE:
                case DEFAULT:
                case DELETE:
                case DO:
                case ELSE:
                case EXTENDS:
                case FALSE:
                case FINALLY:
                case FOR:
                case FUNCTION:
                case IF:
                case IMPLEMENTS:
                case IMPORT:
                case IN:
                case INSTANCEOF:
                case INTERFACE:
                case INTERNAL:
                case IS:
                case NATIVE:
                case NEW:
                case NULL:
                case PACKAGE:
                case PRIVATE:
                case PROTECTED:
                case PUBLIC:
                case RETURN:
                case SUPER:
                case SWITCH:
                case THIS:
                case THROW:
                case TO:
                case TRUE:
                case TRY:
                case TYPEOF:
                case USE:
                case VAR:
                case VOID:
                case WHILE:
                case WITH:
                case EACH:
                case GET:
                case SET:
                case NAMESPACE:
                case INCLUDE:
                case DYNAMIC:
                case FINAL:
                case OVERRIDE:
                case STATIC:
                case STAR:
                case XML_AT:
                    {
                    alt158=2;
                    }
                    break;
                case EOF:
                    {
                    alt158=3;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 158, 1, input);

                    throw nvae;
                }

            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 158, 0, input);

                throw nvae;
            }
            switch (alt158) {
                case 1 :
                    // ASCollector.g3:2505:10: D= DOT I= IDENTIFIER
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DOT,FOLLOW_DOT_in_propertyReferenceSuffix13414); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }
                    I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_propertyReferenceSuffix13420); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    I_tree = (Object)adaptor.create(I);
                    adaptor.addChild(root_0, I_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2506:10: D= DOT xmlPropertyIdentifier
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DOT,FOLLOW_DOT_in_propertyReferenceSuffix13434); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }
                    pushFollow(FOLLOW_xmlPropertyIdentifier_in_propertyReferenceSuffix13438);
                    xmlPropertyIdentifier296=xmlPropertyIdentifier();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPropertyIdentifier296.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2507:10: D= DOT
                    {
                    root_0 = (Object)adaptor.nil();

                    D=(Token)match(input,DOT,FOLLOW_DOT_in_propertyReferenceSuffix13451); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    D_tree = (Object)adaptor.create(D);
                    adaptor.addChild(root_0, D_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 140, propertyReferenceSuffix_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "propertyReferenceSuffix"

    public static class primaryExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "primaryExpression"
    // ASCollector.g3:2511:1: primaryExpression : primaryExpressionHelper ;
    public final ASCollectorParser.primaryExpression_return primaryExpression() throws RecognitionException {
        ASCollectorParser.primaryExpression_return retval = new ASCollectorParser.primaryExpression_return();
        retval.start = input.LT(1);
        int primaryExpression_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.primaryExpressionHelper_return primaryExpressionHelper297 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 141) ) { return retval; }
            // ASCollector.g3:2512:5: ( primaryExpressionHelper )
            // ASCollector.g3:2512:10: primaryExpressionHelper
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_primaryExpressionHelper_in_primaryExpression13482);
            primaryExpressionHelper297=primaryExpressionHelper();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, primaryExpressionHelper297.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 141, primaryExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "primaryExpression"

    public static class primaryExpressionHelper_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "primaryExpressionHelper"
    // ASCollector.g3:2516:1: primaryExpressionHelper : (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | ( identifierLiteral XML_NS_OP )? identifierLiteral | xmlPrimaryExpression | parExpression | LT type GT ( arrayLiteral )? );
    public final ASCollectorParser.primaryExpressionHelper_return primaryExpressionHelper() throws RecognitionException {
        ASCollectorParser.primaryExpressionHelper_return retval = new ASCollectorParser.primaryExpressionHelper_return();
        retval.start = input.LT(1);
        int primaryExpressionHelper_StartIndex = input.index();
        Object root_0 = null;

        Token T=null;
        Token S=null;
        Token XML_NS_OP302=null;
        Token LT306=null;
        Token GT308=null;
        ASCollectorParser.literal_return literal298 = null;

        ASCollectorParser.arrayLiteral_return arrayLiteral299 = null;

        ASCollectorParser.objectLiteral_return objectLiteral300 = null;

        ASCollectorParser.identifierLiteral_return identifierLiteral301 = null;

        ASCollectorParser.identifierLiteral_return identifierLiteral303 = null;

        ASCollectorParser.xmlPrimaryExpression_return xmlPrimaryExpression304 = null;

        ASCollectorParser.parExpression_return parExpression305 = null;

        ASCollectorParser.type_return type307 = null;

        ASCollectorParser.arrayLiteral_return arrayLiteral309 = null;


        Object T_tree=null;
        Object S_tree=null;
        Object XML_NS_OP302_tree=null;
        Object LT306_tree=null;
        Object GT308_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 142) ) { return retval; }
            // ASCollector.g3:2517:5: (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | ( identifierLiteral XML_NS_OP )? identifierLiteral | xmlPrimaryExpression | parExpression | LT type GT ( arrayLiteral )? )
            int alt161=9;
            alt161 = dfa161.predict(input);
            switch (alt161) {
                case 1 :
                    // ASCollector.g3:2517:9: T= THIS
                    {
                    root_0 = (Object)adaptor.nil();

                    T=(Token)match(input,THIS,FOLLOW_THIS_in_primaryExpressionHelper13508); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    T_tree = (Object)adaptor.create(T);
                    adaptor.addChild(root_0, T_tree);
                    }

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2518:9: S= SUPER
                    {
                    root_0 = (Object)adaptor.nil();

                    S=(Token)match(input,SUPER,FOLLOW_SUPER_in_primaryExpressionHelper13521); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    S_tree = (Object)adaptor.create(S);
                    adaptor.addChild(root_0, S_tree);
                    }

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2519:9: literal
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_literal_in_primaryExpressionHelper13532);
                    literal298=literal();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, literal298.getTree());

                    }
                    break;
                case 4 :
                    // ASCollector.g3:2520:9: arrayLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_arrayLiteral_in_primaryExpressionHelper13544);
                    arrayLiteral299=arrayLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayLiteral299.getTree());

                    }
                    break;
                case 5 :
                    // ASCollector.g3:2521:9: objectLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_objectLiteral_in_primaryExpressionHelper13555);
                    objectLiteral300=objectLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, objectLiteral300.getTree());

                    }
                    break;
                case 6 :
                    // ASCollector.g3:2522:9: ( identifierLiteral XML_NS_OP )? identifierLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    // ASCollector.g3:2522:9: ( identifierLiteral XML_NS_OP )?
                    int alt159=2;
                    int LA159_0 = input.LA(1);

                    if ( (LA159_0==IDENTIFIER) ) {
                        int LA159_1 = input.LA(2);

                        if ( (LA159_1==XML_NS_OP) ) {
                            int LA159_3 = input.LA(3);

                            if ( (synpred388_ASCollector()) ) {
                                alt159=1;
                            }
                        }
                    }
                    else if ( (LA159_0==NATIVE||LA159_0==TO||(LA159_0>=EACH && LA159_0<=NAMESPACE)||(LA159_0>=DYNAMIC && LA159_0<=STATIC)) ) {
                        int LA159_2 = input.LA(2);

                        if ( (LA159_2==XML_NS_OP) ) {
                            int LA159_3 = input.LA(3);

                            if ( (synpred388_ASCollector()) ) {
                                alt159=1;
                            }
                        }
                    }
                    switch (alt159) {
                        case 1 :
                            // ASCollector.g3:2522:10: identifierLiteral XML_NS_OP
                            {
                            pushFollow(FOLLOW_identifierLiteral_in_primaryExpressionHelper13568);
                            identifierLiteral301=identifierLiteral();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierLiteral301.getTree());
                            XML_NS_OP302=(Token)match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_primaryExpressionHelper13570); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            XML_NS_OP302_tree = (Object)adaptor.create(XML_NS_OP302);
                            adaptor.addChild(root_0, XML_NS_OP302_tree);
                            }

                            }
                            break;

                    }

                    pushFollow(FOLLOW_identifierLiteral_in_primaryExpressionHelper13574);
                    identifierLiteral303=identifierLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierLiteral303.getTree());

                    }
                    break;
                case 7 :
                    // ASCollector.g3:2523:9: xmlPrimaryExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_xmlPrimaryExpression_in_primaryExpressionHelper13585);
                    xmlPrimaryExpression304=xmlPrimaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, xmlPrimaryExpression304.getTree());

                    }
                    break;
                case 8 :
                    // ASCollector.g3:2524:9: parExpression
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_parExpression_in_primaryExpressionHelper13595);
                    parExpression305=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression305.getTree());

                    }
                    break;
                case 9 :
                    // ASCollector.g3:2525:9: LT type GT ( arrayLiteral )?
                    {
                    root_0 = (Object)adaptor.nil();

                    LT306=(Token)match(input,LT,FOLLOW_LT_in_primaryExpressionHelper13606); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    LT306_tree = (Object)adaptor.create(LT306);
                    adaptor.addChild(root_0, LT306_tree);
                    }
                    pushFollow(FOLLOW_type_in_primaryExpressionHelper13608);
                    type307=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type307.getTree());
                    GT308=(Token)match(input,GT,FOLLOW_GT_in_primaryExpressionHelper13610); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    GT308_tree = (Object)adaptor.create(GT308);
                    adaptor.addChild(root_0, GT308_tree);
                    }
                    // ASCollector.g3:2525:20: ( arrayLiteral )?
                    int alt160=2;
                    alt160 = dfa160.predict(input);
                    switch (alt160) {
                        case 1 :
                            // ASCollector.g3:2525:21: arrayLiteral
                            {
                            pushFollow(FOLLOW_arrayLiteral_in_primaryExpressionHelper13613);
                            arrayLiteral309=arrayLiteral();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayLiteral309.getTree());

                            }
                            break;

                    }


                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 142, primaryExpressionHelper_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "primaryExpressionHelper"

    public static class objectLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "objectLiteral"
    // ASCollector.g3:2529:1: objectLiteral : L= LCURLY ( propertyNameAndValueList )? R= RCURLY ;
    public final ASCollectorParser.objectLiteral_return objectLiteral() throws RecognitionException {
        ASCollectorParser.objectLiteral_return retval = new ASCollectorParser.objectLiteral_return();
        retval.start = input.LT(1);
        int objectLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.propertyNameAndValueList_return propertyNameAndValueList310 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 143) ) { return retval; }
            // ASCollector.g3:2530:5: (L= LCURLY ( propertyNameAndValueList )? R= RCURLY )
            // ASCollector.g3:2530:9: L= LCURLY ( propertyNameAndValueList )? R= RCURLY
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LCURLY,FOLLOW_LCURLY_in_objectLiteral13638); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:2530:19: ( propertyNameAndValueList )?
            int alt162=2;
            int LA162_0 = input.LA(1);

            if ( (LA162_0==NATIVE||LA162_0==TO||(LA162_0>=EACH && LA162_0<=NAMESPACE)||(LA162_0>=DYNAMIC && LA162_0<=STATIC)||(LA162_0>=SINGLE_QUOTE_LITERAL && LA162_0<=DOUBLE_QUOTE_LITERAL)||LA162_0==HEX_NUMBER_LITERAL||LA162_0==DEC_NUMBER_LITERAL||LA162_0==IDENTIFIER) ) {
                alt162=1;
            }
            switch (alt162) {
                case 1 :
                    // ASCollector.g3:0:0: propertyNameAndValueList
                    {
                    pushFollow(FOLLOW_propertyNameAndValueList_in_objectLiteral13641);
                    propertyNameAndValueList310=propertyNameAndValueList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyNameAndValueList310.getTree());

                    }
                    break;

            }

            R=(Token)match(input,RCURLY,FOLLOW_RCURLY_in_objectLiteral13646); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 143, objectLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "objectLiteral"

    public static class propertyNameAndValueList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "propertyNameAndValueList"
    // ASCollector.g3:2533:1: propertyNameAndValueList : propertyNameAndValue (C= COMMA propertyNameAndValue )* ;
    public final ASCollectorParser.propertyNameAndValueList_return propertyNameAndValueList() throws RecognitionException {
        ASCollectorParser.propertyNameAndValueList_return retval = new ASCollectorParser.propertyNameAndValueList_return();
        retval.start = input.LT(1);
        int propertyNameAndValueList_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.propertyNameAndValue_return propertyNameAndValue311 = null;

        ASCollectorParser.propertyNameAndValue_return propertyNameAndValue312 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 144) ) { return retval; }
            // ASCollector.g3:2534:5: ( propertyNameAndValue (C= COMMA propertyNameAndValue )* )
            // ASCollector.g3:2534:9: propertyNameAndValue (C= COMMA propertyNameAndValue )*
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_propertyNameAndValue_in_propertyNameAndValueList13667);
            propertyNameAndValue311=propertyNameAndValue();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyNameAndValue311.getTree());
            // ASCollector.g3:2534:30: (C= COMMA propertyNameAndValue )*
            loop163:
            do {
                int alt163=2;
                int LA163_0 = input.LA(1);

                if ( (LA163_0==COMMA) ) {
                    alt163=1;
                }


                switch (alt163) {
            	case 1 :
            	    // ASCollector.g3:2534:31: C= COMMA propertyNameAndValue
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_propertyNameAndValueList13672); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_propertyNameAndValue_in_propertyNameAndValueList13675);
            	    propertyNameAndValue312=propertyNameAndValue();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyNameAndValue312.getTree());

            	    }
            	    break;

            	default :
            	    break loop163;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 144, propertyNameAndValueList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "propertyNameAndValueList"

    public static class propertyNameAndValue_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "propertyNameAndValue"
    // ASCollector.g3:2537:1: propertyNameAndValue : propertyName C= COLON assignmentExpression ;
    public final ASCollectorParser.propertyNameAndValue_return propertyNameAndValue() throws RecognitionException {
        ASCollectorParser.propertyNameAndValue_return retval = new ASCollectorParser.propertyNameAndValue_return();
        retval.start = input.LT(1);
        int propertyNameAndValue_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.propertyName_return propertyName313 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression314 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 145) ) { return retval; }
            // ASCollector.g3:2538:5: ( propertyName C= COLON assignmentExpression )
            // ASCollector.g3:2538:9: propertyName C= COLON assignmentExpression
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_propertyName_in_propertyNameAndValue13696);
            propertyName313=propertyName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, propertyName313.getTree());
            C=(Token)match(input,COLON,FOLLOW_COLON_in_propertyNameAndValue13700); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            C_tree = (Object)adaptor.create(C);
            adaptor.addChild(root_0, C_tree);
            }
            pushFollow(FOLLOW_assignmentExpression_in_propertyNameAndValue13717);
            assignmentExpression314=assignmentExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression314.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 145, propertyNameAndValue_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "propertyNameAndValue"

    public static class propertyName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "propertyName"
    // ASCollector.g3:2543:1: propertyName : ( identifierLiteral | stringLiteral | numericLiteral );
    public final ASCollectorParser.propertyName_return propertyName() throws RecognitionException {
        ASCollectorParser.propertyName_return retval = new ASCollectorParser.propertyName_return();
        retval.start = input.LT(1);
        int propertyName_StartIndex = input.index();
        Object root_0 = null;

        ASCollectorParser.identifierLiteral_return identifierLiteral315 = null;

        ASCollectorParser.stringLiteral_return stringLiteral316 = null;

        ASCollectorParser.numericLiteral_return numericLiteral317 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 146) ) { return retval; }
            // ASCollector.g3:2544:5: ( identifierLiteral | stringLiteral | numericLiteral )
            int alt164=3;
            switch ( input.LA(1) ) {
            case NATIVE:
            case TO:
            case EACH:
            case GET:
            case SET:
            case NAMESPACE:
            case DYNAMIC:
            case FINAL:
            case OVERRIDE:
            case STATIC:
            case IDENTIFIER:
                {
                alt164=1;
                }
                break;
            case SINGLE_QUOTE_LITERAL:
            case DOUBLE_QUOTE_LITERAL:
                {
                alt164=2;
                }
                break;
            case HEX_NUMBER_LITERAL:
            case DEC_NUMBER_LITERAL:
                {
                alt164=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 164, 0, input);

                throw nvae;
            }

            switch (alt164) {
                case 1 :
                    // ASCollector.g3:2544:9: identifierLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_identifierLiteral_in_propertyName13736);
                    identifierLiteral315=identifierLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierLiteral315.getTree());

                    }
                    break;
                case 2 :
                    // ASCollector.g3:2545:9: stringLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_stringLiteral_in_propertyName13747);
                    stringLiteral316=stringLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, stringLiteral316.getTree());

                    }
                    break;
                case 3 :
                    // ASCollector.g3:2546:9: numericLiteral
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_numericLiteral_in_propertyName13758);
                    numericLiteral317=numericLiteral();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, numericLiteral317.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 146, propertyName_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "propertyName"

    public static class arrayLiteral_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "arrayLiteral"
    // ASCollector.g3:2550:1: arrayLiteral : L= LBRACK ( elementList )? R= RBRACK ;
    public final ASCollectorParser.arrayLiteral_return arrayLiteral() throws RecognitionException {
        ASCollectorParser.arrayLiteral_return retval = new ASCollectorParser.arrayLiteral_return();
        retval.start = input.LT(1);
        int arrayLiteral_StartIndex = input.index();
        Object root_0 = null;

        Token L=null;
        Token R=null;
        ASCollectorParser.elementList_return elementList318 = null;


        Object L_tree=null;
        Object R_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 147) ) { return retval; }
            // ASCollector.g3:2551:5: (L= LBRACK ( elementList )? R= RBRACK )
            // ASCollector.g3:2551:9: L= LBRACK ( elementList )? R= RBRACK
            {
            root_0 = (Object)adaptor.nil();

            L=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_arrayLiteral13781); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            L_tree = (Object)adaptor.create(L);
            adaptor.addChild(root_0, L_tree);
            }
            // ASCollector.g3:2551:19: ( elementList )?
            int alt165=2;
            int LA165_0 = input.LA(1);

            if ( ((LA165_0>=AS && LA165_0<=STATIC)||LA165_0==LCURLY||LA165_0==LPAREN||LA165_0==LBRACK||LA165_0==LT||(LA165_0>=PLUS && LA165_0<=STAR)||(LA165_0>=INC && LA165_0<=DEC)||(LA165_0>=NOT && LA165_0<=INV)||(LA165_0>=XML_AT && LA165_0<=XML_LS_STD)||(LA165_0>=SINGLE_QUOTE_LITERAL && LA165_0<=DOUBLE_QUOTE_LITERAL)||LA165_0==REGULAR_EXPR_LITERAL||LA165_0==HEX_NUMBER_LITERAL||LA165_0==DEC_NUMBER_LITERAL||LA165_0==IDENTIFIER||(LA165_0>=XML_COMMENT && LA165_0<=XML_PI)) ) {
                alt165=1;
            }
            switch (alt165) {
                case 1 :
                    // ASCollector.g3:0:0: elementList
                    {
                    pushFollow(FOLLOW_elementList_in_arrayLiteral13784);
                    elementList318=elementList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, elementList318.getTree());

                    }
                    break;

            }

            R=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_arrayLiteral13789); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            R_tree = (Object)adaptor.create(R);
            adaptor.addChild(root_0, R_tree);
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 147, arrayLiteral_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "arrayLiteral"

    public static class elementList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "elementList"
    // ASCollector.g3:2554:1: elementList : assignmentExpression (C= COMMA assignmentExpression )* (C= COMMA )? ;
    public final ASCollectorParser.elementList_return elementList() throws RecognitionException {
        ASCollectorParser.elementList_return retval = new ASCollectorParser.elementList_return();
        retval.start = input.LT(1);
        int elementList_StartIndex = input.index();
        Object root_0 = null;

        Token C=null;
        ASCollectorParser.assignmentExpression_return assignmentExpression319 = null;

        ASCollectorParser.assignmentExpression_return assignmentExpression320 = null;


        Object C_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 148) ) { return retval; }
            // ASCollector.g3:2555:5: ( assignmentExpression (C= COMMA assignmentExpression )* (C= COMMA )? )
            // ASCollector.g3:2558:9: assignmentExpression (C= COMMA assignmentExpression )* (C= COMMA )?
            {
            root_0 = (Object)adaptor.nil();

            pushFollow(FOLLOW_assignmentExpression_in_elementList13827);
            assignmentExpression319=assignmentExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression319.getTree());
            // ASCollector.g3:2559:6: (C= COMMA assignmentExpression )*
            loop166:
            do {
                int alt166=2;
                int LA166_0 = input.LA(1);

                if ( (LA166_0==COMMA) ) {
                    int LA166_1 = input.LA(2);

                    if ( ((LA166_1>=AS && LA166_1<=STATIC)||LA166_1==LCURLY||LA166_1==LPAREN||LA166_1==LBRACK||LA166_1==LT||(LA166_1>=PLUS && LA166_1<=STAR)||(LA166_1>=INC && LA166_1<=DEC)||(LA166_1>=NOT && LA166_1<=INV)||(LA166_1>=XML_AT && LA166_1<=XML_LS_STD)||(LA166_1>=SINGLE_QUOTE_LITERAL && LA166_1<=DOUBLE_QUOTE_LITERAL)||LA166_1==REGULAR_EXPR_LITERAL||LA166_1==HEX_NUMBER_LITERAL||LA166_1==DEC_NUMBER_LITERAL||LA166_1==IDENTIFIER||(LA166_1>=XML_COMMENT && LA166_1<=XML_PI)) ) {
                        alt166=1;
                    }


                }


                switch (alt166) {
            	case 1 :
            	    // ASCollector.g3:2560:7: C= COMMA assignmentExpression
            	    {
            	    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementList13845); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    C_tree = (Object)adaptor.create(C);
            	    adaptor.addChild(root_0, C_tree);
            	    }
            	    pushFollow(FOLLOW_assignmentExpression_in_elementList13861);
            	    assignmentExpression320=assignmentExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentExpression320.getTree());

            	    }
            	    break;

            	default :
            	    break loop166;
                }
            } while (true);

            // ASCollector.g3:2563:9: (C= COMMA )?
            int alt167=2;
            int LA167_0 = input.LA(1);

            if ( (LA167_0==COMMA) ) {
                alt167=1;
            }
            switch (alt167) {
                case 1 :
                    // ASCollector.g3:2563:10: C= COMMA
                    {
                    C=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementList13874); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    C_tree = (Object)adaptor.create(C);
                    adaptor.addChild(root_0, C_tree);
                    }

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 148, elementList_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "elementList"

    // $ANTLR start synpred9_ASCollector
    public final void synpred9_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:845:69: ({...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords ) )
        // ASCollector.g3:845:69: {...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords )
        {
        if ( !((!promoteWhitespace())) ) {
            if (state.backtracking>0) {state.failed=true; return ;}
            throw new FailedPredicateException(input, "synpred9_ASCollector", "!promoteWhitespace()");
        }
        if ( input.LA(1)==DOT||input.LA(1)==SUB||input.LA(1)==COLON ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }

        if ( !((!promoteWhitespace())) ) {
            if (state.backtracking>0) {state.failed=true; return ;}
            throw new FailedPredicateException(input, "synpred9_ASCollector", "!promoteWhitespace()");
        }
        // ASCollector.g3:845:141: ( IDENTIFIER | allKeywords )
        int alt168=2;
        int LA168_0 = input.LA(1);

        if ( (LA168_0==IDENTIFIER) ) {
            alt168=1;
        }
        else if ( ((LA168_0>=AS && LA168_0<=STATIC)) ) {
            alt168=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 168, 0, input);

            throw nvae;
        }
        switch (alt168) {
            case 1 :
                // ASCollector.g3:845:142: IDENTIFIER
                {
                match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred9_ASCollector3845); if (state.failed) return ;

                }
                break;
            case 2 :
                // ASCollector.g3:845:155: allKeywords
                {
                pushFollow(FOLLOW_allKeywords_in_synpred9_ASCollector3849);
                allKeywords();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        }
    }
    // $ANTLR end synpred9_ASCollector

    // $ANTLR start synpred68_ASCollector
    public final void synpred68_ASCollector_fragment() throws RecognitionException {   
        Token x=null;

        // ASCollector.g3:939:6: (x= XML_TEXT )
        // ASCollector.g3:939:6: x= XML_TEXT
        {
        x=(Token)match(input,XML_TEXT,FOLLOW_XML_TEXT_in_synpred68_ASCollector4878); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred68_ASCollector

    // $ANTLR start synpred69_ASCollector
    public final void synpred69_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:939:20: ( xmlTextElement )
        // ASCollector.g3:939:20: xmlTextElement
        {
        pushFollow(FOLLOW_xmlTextElement_in_synpred69_ASCollector4883);
        xmlTextElement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred69_ASCollector

    // $ANTLR start synpred73_ASCollector
    public final void synpred73_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:961:11: ( xmlQualifiedIdentifier )
        // ASCollector.g3:961:11: xmlQualifiedIdentifier
        {
        pushFollow(FOLLOW_xmlQualifiedIdentifier_in_synpred73_ASCollector5032);
        xmlQualifiedIdentifier();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred73_ASCollector

    // $ANTLR start synpred74_ASCollector
    public final void synpred74_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:968:12: ( xmlQualifiedIdentifier )
        // ASCollector.g3:968:12: xmlQualifiedIdentifier
        {
        pushFollow(FOLLOW_xmlQualifiedIdentifier_in_synpred74_ASCollector5135);
        xmlQualifiedIdentifier();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred74_ASCollector

    // $ANTLR start synpred75_ASCollector
    public final void synpred75_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:969:14: ( xmlPropertySelector )
        // ASCollector.g3:969:14: xmlPropertySelector
        {
        pushFollow(FOLLOW_xmlPropertySelector_in_synpred75_ASCollector5150);
        xmlPropertySelector();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred75_ASCollector

    // $ANTLR start synpred97_ASCollector
    public final void synpred97_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1105:4: ( conditionalCompilerOption LCURLY mxmlEmbedded RCURLY )
        // ASCollector.g3:1105:4: conditionalCompilerOption LCURLY mxmlEmbedded RCURLY
        {
        pushFollow(FOLLOW_conditionalCompilerOption_in_synpred97_ASCollector5936);
        conditionalCompilerOption();

        state._fsp--;
        if (state.failed) return ;
        match(input,LCURLY,FOLLOW_LCURLY_in_synpred97_ASCollector5938); if (state.failed) return ;
        pushFollow(FOLLOW_mxmlEmbedded_in_synpred97_ASCollector5940);
        mxmlEmbedded();

        state._fsp--;
        if (state.failed) return ;
        match(input,RCURLY,FOLLOW_RCURLY_in_synpred97_ASCollector5942); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred97_ASCollector

    // $ANTLR start synpred98_ASCollector
    public final void synpred98_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1106:9: ( propertyDeclaration )
        // ASCollector.g3:1106:9: propertyDeclaration
        {
        pushFollow(FOLLOW_propertyDeclaration_in_synpred98_ASCollector5955);
        propertyDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred98_ASCollector

    // $ANTLR start synpred99_ASCollector
    public final void synpred99_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1106:31: ( functionDeclaration[true] )
        // ASCollector.g3:1106:31: functionDeclaration[true]
        {
        pushFollow(FOLLOW_functionDeclaration_in_synpred99_ASCollector5959);
        functionDeclaration(true);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred99_ASCollector

    // $ANTLR start synpred100_ASCollector
    public final void synpred100_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1106:59: ( statement )
        // ASCollector.g3:1106:59: statement
        {
        pushFollow(FOLLOW_statement_in_synpred100_ASCollector5964);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred100_ASCollector

    // $ANTLR start synpred101_ASCollector
    public final void synpred101_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1106:71: ( directive )
        // ASCollector.g3:1106:71: directive
        {
        pushFollow(FOLLOW_directive_in_synpred101_ASCollector5968);
        directive();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred101_ASCollector

    // $ANTLR start synpred102_ASCollector
    public final void synpred102_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1106:83: ( interfaceFunctionDeclaration[true] )
        // ASCollector.g3:1106:83: interfaceFunctionDeclaration[true]
        {
        pushFollow(FOLLOW_interfaceFunctionDeclaration_in_synpred102_ASCollector5972);
        interfaceFunctionDeclaration(true);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred102_ASCollector

    // $ANTLR start synpred105_ASCollector
    public final void synpred105_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1112:4: ( conditionalCompilerOption LCURLY ( packageElement )* RCURLY )
        // ASCollector.g3:1112:4: conditionalCompilerOption LCURLY ( packageElement )* RCURLY
        {
        pushFollow(FOLLOW_conditionalCompilerOption_in_synpred105_ASCollector6005);
        conditionalCompilerOption();

        state._fsp--;
        if (state.failed) return ;
        match(input,LCURLY,FOLLOW_LCURLY_in_synpred105_ASCollector6007); if (state.failed) return ;
        // ASCollector.g3:1112:37: ( packageElement )*
        loop171:
        do {
            int alt171=2;
            int LA171_0 = input.LA(1);

            if ( ((LA171_0>=AS && LA171_0<=LCURLY)||LA171_0==LPAREN||LA171_0==LBRACK||LA171_0==LT||(LA171_0>=PLUS && LA171_0<=STAR)||(LA171_0>=INC && LA171_0<=DEC)||(LA171_0>=NOT && LA171_0<=INV)||(LA171_0>=XML_AT && LA171_0<=XML_LS_STD)||(LA171_0>=SINGLE_QUOTE_LITERAL && LA171_0<=DOUBLE_QUOTE_LITERAL)||LA171_0==REGULAR_EXPR_LITERAL||LA171_0==HEX_NUMBER_LITERAL||LA171_0==DEC_NUMBER_LITERAL||LA171_0==IDENTIFIER||(LA171_0>=XML_COMMENT && LA171_0<=XML_PI)) ) {
                alt171=1;
            }


            switch (alt171) {
        	case 1 :
        	    // ASCollector.g3:0:0: packageElement
        	    {
        	    pushFollow(FOLLOW_packageElement_in_synpred105_ASCollector6009);
        	    packageElement();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop171;
            }
        } while (true);

        match(input,RCURLY,FOLLOW_RCURLY_in_synpred105_ASCollector6012); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred105_ASCollector

    // $ANTLR start synpred106_ASCollector
    public final void synpred106_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1113:9: ( classOrInterfaceDecl )
        // ASCollector.g3:1113:9: classOrInterfaceDecl
        {
        pushFollow(FOLLOW_classOrInterfaceDecl_in_synpred106_ASCollector6029);
        classOrInterfaceDecl();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred106_ASCollector

    // $ANTLR start synpred107_ASCollector
    public final void synpred107_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1113:32: ( propertyDeclaration )
        // ASCollector.g3:1113:32: propertyDeclaration
        {
        pushFollow(FOLLOW_propertyDeclaration_in_synpred107_ASCollector6033);
        propertyDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred107_ASCollector

    // $ANTLR start synpred108_ASCollector
    public final void synpred108_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1113:54: ( functionDeclaration[true] )
        // ASCollector.g3:1113:54: functionDeclaration[true]
        {
        pushFollow(FOLLOW_functionDeclaration_in_synpred108_ASCollector6037);
        functionDeclaration(true);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred108_ASCollector

    // $ANTLR start synpred109_ASCollector
    public final void synpred109_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1113:82: ( interfaceFunctionDeclaration[true] )
        // ASCollector.g3:1113:82: interfaceFunctionDeclaration[true]
        {
        pushFollow(FOLLOW_interfaceFunctionDeclaration_in_synpred109_ASCollector6042);
        interfaceFunctionDeclaration(true);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred109_ASCollector

    // $ANTLR start synpred110_ASCollector
    public final void synpred110_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1113:119: ( directive )
        // ASCollector.g3:1113:119: directive
        {
        pushFollow(FOLLOW_directive_in_synpred110_ASCollector6047);
        directive();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred110_ASCollector

    // $ANTLR start synpred124_ASCollector
    public final void synpred124_ASCollector_fragment() throws RecognitionException {   
        Token s=null;

        // ASCollector.g3:1237:15: (s= SEMI )
        // ASCollector.g3:1237:15: s= SEMI
        {
        s=(Token)match(input,SEMI,FOLLOW_SEMI_in_synpred124_ASCollector6520); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred124_ASCollector

    // $ANTLR start synpred125_ASCollector
    public final void synpred125_ASCollector_fragment() throws RecognitionException {   
        Token E=null;

        // ASCollector.g3:1295:3: ( eitherIdentifier E= ASSIGN )
        // ASCollector.g3:1295:3: eitherIdentifier E= ASSIGN
        {
        pushFollow(FOLLOW_eitherIdentifier_in_synpred125_ASCollector6577);
        eitherIdentifier();

        state._fsp--;
        if (state.failed) return ;
        E=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred125_ASCollector6582); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred125_ASCollector

    // $ANTLR start synpred136_ASCollector
    public final void synpred136_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1374:9: ( conditionalCompilerOption LCURLY )
        // ASCollector.g3:1374:10: conditionalCompilerOption LCURLY
        {
        pushFollow(FOLLOW_conditionalCompilerOption_in_synpred136_ASCollector6934);
        conditionalCompilerOption();

        state._fsp--;
        if (state.failed) return ;
        match(input,LCURLY,FOLLOW_LCURLY_in_synpred136_ASCollector6936); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred136_ASCollector

    // $ANTLR start synpred138_ASCollector
    public final void synpred138_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1375:8: ( propertyDeclaration )
        // ASCollector.g3:1375:8: propertyDeclaration
        {
        pushFollow(FOLLOW_propertyDeclaration_in_synpred138_ASCollector6958);
        propertyDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred138_ASCollector

    // $ANTLR start synpred139_ASCollector
    public final void synpred139_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1375:30: ( functionDeclaration[true] )
        // ASCollector.g3:1375:30: functionDeclaration[true]
        {
        pushFollow(FOLLOW_functionDeclaration_in_synpred139_ASCollector6962);
        functionDeclaration(true);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred139_ASCollector

    // $ANTLR start synpred140_ASCollector
    public final void synpred140_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1375:58: ( directive )
        // ASCollector.g3:1375:58: directive
        {
        pushFollow(FOLLOW_directive_in_synpred140_ASCollector6967);
        directive();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred140_ASCollector

    // $ANTLR start synpred141_ASCollector
    public final void synpred141_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1379:9: ( conditionalCompilerOption LCURLY )
        // ASCollector.g3:1379:10: conditionalCompilerOption LCURLY
        {
        pushFollow(FOLLOW_conditionalCompilerOption_in_synpred141_ASCollector6988);
        conditionalCompilerOption();

        state._fsp--;
        if (state.failed) return ;
        match(input,LCURLY,FOLLOW_LCURLY_in_synpred141_ASCollector6990); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred141_ASCollector

    // $ANTLR start synpred143_ASCollector
    public final void synpred143_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1380:8: ( propertyDeclaration )
        // ASCollector.g3:1380:8: propertyDeclaration
        {
        pushFollow(FOLLOW_propertyDeclaration_in_synpred143_ASCollector7016);
        propertyDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred143_ASCollector

    // $ANTLR start synpred144_ASCollector
    public final void synpred144_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1380:30: ( interfaceFunctionDeclaration[true] )
        // ASCollector.g3:1380:30: interfaceFunctionDeclaration[true]
        {
        pushFollow(FOLLOW_interfaceFunctionDeclaration_in_synpred144_ASCollector7020);
        interfaceFunctionDeclaration(true);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred144_ASCollector

    // $ANTLR start synpred145_ASCollector
    public final void synpred145_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1380:67: ( directive )
        // ASCollector.g3:1380:67: directive
        {
        pushFollow(FOLLOW_directive_in_synpred145_ASCollector7025);
        directive();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred145_ASCollector

    // $ANTLR start synpred153_ASCollector
    public final void synpred153_ASCollector_fragment() throws RecognitionException {   
        ASCollectorParser.memberModifiers_return m = null;


        // ASCollector.g3:1481:4: (m= memberModifiers[rec] )
        // ASCollector.g3:1481:4: m= memberModifiers[rec]
        {
        pushFollow(FOLLOW_memberModifiers_in_synpred153_ASCollector7338);
        m=memberModifiers(rec);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred153_ASCollector

    // $ANTLR start synpred168_ASCollector
    public final void synpred168_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1622:8: ( statement )
        // ASCollector.g3:1622:8: statement
        {
        pushFollow(FOLLOW_statement_in_synpred168_ASCollector8024);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred168_ASCollector

    // $ANTLR start synpred169_ASCollector
    public final void synpred169_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1622:18: ( functionDeclaration[false] )
        // ASCollector.g3:1622:18: functionDeclaration[false]
        {
        pushFollow(FOLLOW_functionDeclaration_in_synpred169_ASCollector8026);
        functionDeclaration(false);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred169_ASCollector

    // $ANTLR start synpred170_ASCollector
    public final void synpred170_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1633:6: ( memberModifier[rec] )
        // ASCollector.g3:1633:6: memberModifier[rec]
        {
        pushFollow(FOLLOW_memberModifier_in_synpred170_ASCollector8072);
        memberModifier(rec);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred170_ASCollector

    // $ANTLR start synpred180_ASCollector
    public final void synpred180_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1672:7: ( blockStatement )
        // ASCollector.g3:1672:7: blockStatement
        {
        pushFollow(FOLLOW_blockStatement_in_synpred180_ASCollector8253);
        blockStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred180_ASCollector

    // $ANTLR start synpred181_ASCollector
    public final void synpred181_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1673:9: ( directive )
        // ASCollector.g3:1673:9: directive
        {
        pushFollow(FOLLOW_directive_in_synpred181_ASCollector8263);
        directive();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred181_ASCollector

    // $ANTLR start synpred182_ASCollector
    public final void synpred182_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1674:9: ( namespaceDirective[null] )
        // ASCollector.g3:1674:9: namespaceDirective[null]
        {
        pushFollow(FOLLOW_namespaceDirective_in_synpred182_ASCollector8273);
        namespaceDirective(null);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred182_ASCollector

    // $ANTLR start synpred183_ASCollector
    public final void synpred183_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1675:10: ( constantVarStatement[null] )
        // ASCollector.g3:1675:10: constantVarStatement[null]
        {
        pushFollow(FOLLOW_constantVarStatement_in_synpred183_ASCollector8285);
        constantVarStatement(null);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred183_ASCollector

    // $ANTLR start synpred184_ASCollector
    public final void synpred184_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1676:9: ( tryStatement )
        // ASCollector.g3:1676:9: tryStatement
        {
        pushFollow(FOLLOW_tryStatement_in_synpred184_ASCollector8297);
        tryStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred184_ASCollector

    // $ANTLR start synpred185_ASCollector
    public final void synpred185_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1677:9: ( switchStatement )
        // ASCollector.g3:1677:9: switchStatement
        {
        pushFollow(FOLLOW_switchStatement_in_synpred185_ASCollector8307);
        switchStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred185_ASCollector

    // $ANTLR start synpred186_ASCollector
    public final void synpred186_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1678:9: ( withStatement )
        // ASCollector.g3:1678:9: withStatement
        {
        pushFollow(FOLLOW_withStatement_in_synpred186_ASCollector8317);
        withStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred186_ASCollector

    // $ANTLR start synpred187_ASCollector
    public final void synpred187_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1679:11: ( returnStatement )
        // ASCollector.g3:1679:11: returnStatement
        {
        pushFollow(FOLLOW_returnStatement_in_synpred187_ASCollector8329);
        returnStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred187_ASCollector

    // $ANTLR start synpred188_ASCollector
    public final void synpred188_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1680:11: ( breakStatement )
        // ASCollector.g3:1680:11: breakStatement
        {
        pushFollow(FOLLOW_breakStatement_in_synpred188_ASCollector8342);
        breakStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred188_ASCollector

    // $ANTLR start synpred189_ASCollector
    public final void synpred189_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1681:11: ( continueStatement )
        // ASCollector.g3:1681:11: continueStatement
        {
        pushFollow(FOLLOW_continueStatement_in_synpred189_ASCollector8355);
        continueStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred189_ASCollector

    // $ANTLR start synpred190_ASCollector
    public final void synpred190_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1682:9: ( forStatement )
        // ASCollector.g3:1682:9: forStatement
        {
        pushFollow(FOLLOW_forStatement_in_synpred190_ASCollector8366);
        forStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred190_ASCollector

    // $ANTLR start synpred191_ASCollector
    public final void synpred191_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1683:9: ( forInStatement )
        // ASCollector.g3:1683:9: forInStatement
        {
        pushFollow(FOLLOW_forInStatement_in_synpred191_ASCollector8376);
        forInStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred191_ASCollector

    // $ANTLR start synpred192_ASCollector
    public final void synpred192_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1684:9: ( forEachInStatement )
        // ASCollector.g3:1684:9: forEachInStatement
        {
        pushFollow(FOLLOW_forEachInStatement_in_synpred192_ASCollector8386);
        forEachInStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred192_ASCollector

    // $ANTLR start synpred193_ASCollector
    public final void synpred193_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1685:9: ( doWhileStatement )
        // ASCollector.g3:1685:9: doWhileStatement
        {
        pushFollow(FOLLOW_doWhileStatement_in_synpred193_ASCollector8396);
        doWhileStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred193_ASCollector

    // $ANTLR start synpred194_ASCollector
    public final void synpred194_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1686:9: ( whileStatement )
        // ASCollector.g3:1686:9: whileStatement
        {
        pushFollow(FOLLOW_whileStatement_in_synpred194_ASCollector8406);
        whileStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred194_ASCollector

    // $ANTLR start synpred195_ASCollector
    public final void synpred195_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1687:9: ( ifStatement )
        // ASCollector.g3:1687:9: ifStatement
        {
        pushFollow(FOLLOW_ifStatement_in_synpred195_ASCollector8416);
        ifStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred195_ASCollector

    // $ANTLR start synpred196_ASCollector
    public final void synpred196_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1688:11: ( variableStatement[null] )
        // ASCollector.g3:1688:11: variableStatement[null]
        {
        pushFollow(FOLLOW_variableStatement_in_synpred196_ASCollector8428);
        variableStatement(null);

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred196_ASCollector

    // $ANTLR start synpred197_ASCollector
    public final void synpred197_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1689:11: ( throwStatement )
        // ASCollector.g3:1689:11: throwStatement
        {
        pushFollow(FOLLOW_throwStatement_in_synpred197_ASCollector8442);
        throwStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred197_ASCollector

    // $ANTLR start synpred198_ASCollector
    public final void synpred198_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1690:9: ( labelledStatement )
        // ASCollector.g3:1690:9: labelledStatement
        {
        pushFollow(FOLLOW_labelledStatement_in_synpred198_ASCollector8453);
        labelledStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred198_ASCollector

    // $ANTLR start synpred199_ASCollector
    public final void synpred199_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1691:10: ( expression semic )
        // ASCollector.g3:1691:10: expression semic
        {
        pushFollow(FOLLOW_expression_in_synpred199_ASCollector8465);
        expression();

        state._fsp--;
        if (state.failed) return ;
        pushFollow(FOLLOW_semic_in_synpred199_ASCollector8467);
        semic();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred199_ASCollector

    // $ANTLR start synpred202_ASCollector
    public final void synpred202_ASCollector_fragment() throws RecognitionException {   
        Token S=null;

        // ASCollector.g3:1759:41: (S= SEMI )
        // ASCollector.g3:1759:41: S= SEMI
        {
        S=(Token)match(input,SEMI,FOLLOW_SEMI_in_synpred202_ASCollector8658); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred202_ASCollector

    // $ANTLR start synpred206_ASCollector
    public final void synpred206_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1843:11: ( ( catchClause )+ finallyClause )
        // ASCollector.g3:1843:11: ( catchClause )+ finallyClause
        {
        // ASCollector.g3:1843:11: ( catchClause )+
        int cnt178=0;
        loop178:
        do {
            int alt178=2;
            int LA178_0 = input.LA(1);

            if ( (LA178_0==CATCH) ) {
                alt178=1;
            }


            switch (alt178) {
        	case 1 :
        	    // ASCollector.g3:0:0: catchClause
        	    {
        	    pushFollow(FOLLOW_catchClause_in_synpred206_ASCollector8859);
        	    catchClause();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    if ( cnt178 >= 1 ) break loop178;
        	    if (state.backtracking>0) {state.failed=true; return ;}
                    EarlyExitException eee =
                        new EarlyExitException(178, input);
                    throw eee;
            }
            cnt178++;
        } while (true);

        pushFollow(FOLLOW_finallyClause_in_synpred206_ASCollector8862);
        finallyClause();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred206_ASCollector

    // $ANTLR start synpred208_ASCollector
    public final void synpred208_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1844:11: ( ( catchClause )+ )
        // ASCollector.g3:1844:11: ( catchClause )+
        {
        // ASCollector.g3:1844:11: ( catchClause )+
        int cnt179=0;
        loop179:
        do {
            int alt179=2;
            int LA179_0 = input.LA(1);

            if ( (LA179_0==CATCH) ) {
                alt179=1;
            }


            switch (alt179) {
        	case 1 :
        	    // ASCollector.g3:0:0: catchClause
        	    {
        	    pushFollow(FOLLOW_catchClause_in_synpred208_ASCollector8874);
        	    catchClause();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    if ( cnt179 >= 1 ) break loop179;
        	    if (state.backtracking>0) {state.failed=true; return ;}
                    EarlyExitException eee =
                        new EarlyExitException(179, input);
                    throw eee;
            }
            cnt179++;
        } while (true);


        }
    }
    // $ANTLR end synpred208_ASCollector

    // $ANTLR start synpred210_ASCollector
    public final void synpred210_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:1886:23: ( statement )
        // ASCollector.g3:1886:23: statement
        {
        pushFollow(FOLLOW_statement_in_synpred210_ASCollector9115);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred210_ASCollector

    // $ANTLR start synpred221_ASCollector
    public final void synpred221_ASCollector_fragment() throws RecognitionException {   
        Token S=null;

        // ASCollector.g3:1979:58: (S= SEMI )
        // ASCollector.g3:1979:58: S= SEMI
        {
        S=(Token)match(input,SEMI,FOLLOW_SEMI_in_synpred221_ASCollector9702); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred221_ASCollector

    // $ANTLR start synpred222_ASCollector
    public final void synpred222_ASCollector_fragment() throws RecognitionException {   
        Token E=null;

        // ASCollector.g3:2007:26: (E= ELSE statement )
        // ASCollector.g3:2007:26: E= ELSE statement
        {
        E=(Token)match(input,ELSE,FOLLOW_ELSE_in_synpred222_ASCollector9889); if (state.failed) return ;
        pushFollow(FOLLOW_statement_in_synpred222_ASCollector9925);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred222_ASCollector

    // $ANTLR start synpred237_ASCollector
    public final void synpred237_ASCollector_fragment() throws RecognitionException {   
        Token C=null;
        ASCollectorParser.assignmentExpression_return a1 = null;


        // ASCollector.g3:2146:32: (C= COMMA a1= assignmentExpression )
        // ASCollector.g3:2146:32: C= COMMA a1= assignmentExpression
        {
        C=(Token)match(input,COMMA,FOLLOW_COMMA_in_synpred237_ASCollector10630); if (state.failed) return ;
        pushFollow(FOLLOW_assignmentExpression_in_synpred237_ASCollector10636);
        a1=assignmentExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred237_ASCollector

    // $ANTLR start synpred239_ASCollector
    public final void synpred239_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2157:7: ( leftHandSideExpression assignmentOperator )
        // ASCollector.g3:2157:8: leftHandSideExpression assignmentOperator
        {
        pushFollow(FOLLOW_leftHandSideExpression_in_synpred239_ASCollector10704);
        leftHandSideExpression();

        state._fsp--;
        if (state.failed) return ;
        pushFollow(FOLLOW_assignmentOperator_in_synpred239_ASCollector10707);
        assignmentOperator();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred239_ASCollector

    // $ANTLR start synpred240_ASCollector
    public final void synpred240_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2164:7: ( leftHandSideExpression assignmentOperator )
        // ASCollector.g3:2164:8: leftHandSideExpression assignmentOperator
        {
        pushFollow(FOLLOW_leftHandSideExpression_in_synpred240_ASCollector10753);
        leftHandSideExpression();

        state._fsp--;
        if (state.failed) return ;
        pushFollow(FOLLOW_assignmentOperator_in_synpred240_ASCollector10756);
        assignmentOperator();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred240_ASCollector

    // $ANTLR start synpred248_ASCollector
    public final void synpred248_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2192:5: ( '>' '>' '=' )
        // ASCollector.g3:2192:6: '>' '>' '='
        {
        match(input,GT,FOLLOW_GT_in_synpred248_ASCollector10900); if (state.failed) return ;
        match(input,GT,FOLLOW_GT_in_synpred248_ASCollector10902); if (state.failed) return ;
        match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred248_ASCollector10904); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred248_ASCollector

    // $ANTLR start synpred249_ASCollector
    public final void synpred249_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2202:5: ( '>' '>' '>' '=' )
        // ASCollector.g3:2202:6: '>' '>' '>' '='
        {
        match(input,GT,FOLLOW_GT_in_synpred249_ASCollector10963); if (state.failed) return ;
        match(input,GT,FOLLOW_GT_in_synpred249_ASCollector10965); if (state.failed) return ;
        match(input,GT,FOLLOW_GT_in_synpred249_ASCollector10967); if (state.failed) return ;
        match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred249_ASCollector10969); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred249_ASCollector

    // $ANTLR start synpred254_ASCollector
    public final void synpred254_ASCollector_fragment() throws RecognitionException {   
        Token Q=null;
        Token C=null;

        // ASCollector.g3:2220:31: (Q= QUE assignmentExpression C= COLON assignmentExpression )
        // ASCollector.g3:2220:31: Q= QUE assignmentExpression C= COLON assignmentExpression
        {
        Q=(Token)match(input,QUE,FOLLOW_QUE_in_synpred254_ASCollector11080); if (state.failed) return ;
        pushFollow(FOLLOW_assignmentExpression_in_synpred254_ASCollector11084);
        assignmentExpression();

        state._fsp--;
        if (state.failed) return ;
        C=(Token)match(input,COLON,FOLLOW_COLON_in_synpred254_ASCollector11090); if (state.failed) return ;
        pushFollow(FOLLOW_assignmentExpression_in_synpred254_ASCollector11094);
        assignmentExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred254_ASCollector

    // $ANTLR start synpred256_ASCollector
    public final void synpred256_ASCollector_fragment() throws RecognitionException {   
        Token L=null;

        // ASCollector.g3:2229:32: (L= LOR logicalANDExpression )
        // ASCollector.g3:2229:32: L= LOR logicalANDExpression
        {
        L=(Token)match(input,LOR,FOLLOW_LOR_in_synpred256_ASCollector11176); if (state.failed) return ;
        pushFollow(FOLLOW_logicalANDExpression_in_synpred256_ASCollector11179);
        logicalANDExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred256_ASCollector

    // $ANTLR start synpred258_ASCollector
    public final void synpred258_ASCollector_fragment() throws RecognitionException {   
        Token L=null;

        // ASCollector.g3:2237:31: (L= LAND bitwiseORExpression )
        // ASCollector.g3:2237:31: L= LAND bitwiseORExpression
        {
        L=(Token)match(input,LAND,FOLLOW_LAND_in_synpred258_ASCollector11252); if (state.failed) return ;
        pushFollow(FOLLOW_bitwiseORExpression_in_synpred258_ASCollector11255);
        bitwiseORExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred258_ASCollector

    // $ANTLR start synpred260_ASCollector
    public final void synpred260_ASCollector_fragment() throws RecognitionException {   
        Token O=null;

        // ASCollector.g3:2246:32: (O= OR bitwiseXORExpression )
        // ASCollector.g3:2246:32: O= OR bitwiseXORExpression
        {
        O=(Token)match(input,OR,FOLLOW_OR_in_synpred260_ASCollector11327); if (state.failed) return ;
        pushFollow(FOLLOW_bitwiseXORExpression_in_synpred260_ASCollector11330);
        bitwiseXORExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred260_ASCollector

    // $ANTLR start synpred262_ASCollector
    public final void synpred262_ASCollector_fragment() throws RecognitionException {   
        Token x=null;

        // ASCollector.g3:2254:32: (x= XOR bitwiseANDExpression )
        // ASCollector.g3:2254:32: x= XOR bitwiseANDExpression
        {
        x=(Token)match(input,XOR,FOLLOW_XOR_in_synpred262_ASCollector11401); if (state.failed) return ;
        pushFollow(FOLLOW_bitwiseANDExpression_in_synpred262_ASCollector11404);
        bitwiseANDExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred262_ASCollector

    // $ANTLR start synpred264_ASCollector
    public final void synpred264_ASCollector_fragment() throws RecognitionException {   
        Token A=null;

        // ASCollector.g3:2262:30: (A= AND equalityExpression )
        // ASCollector.g3:2262:30: A= AND equalityExpression
        {
        A=(Token)match(input,AND,FOLLOW_AND_in_synpred264_ASCollector11471); if (state.failed) return ;
        pushFollow(FOLLOW_equalityExpression_in_synpred264_ASCollector11474);
        equalityExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred264_ASCollector

    // $ANTLR start synpred269_ASCollector
    public final void synpred269_ASCollector_fragment() throws RecognitionException {   
        Token eq=null;

        // ASCollector.g3:2271:32: (eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression )
        // ASCollector.g3:2271:32: eq= ( EQ | NEQ | SAME | NSAME ) relationalExpression
        {
        eq=(Token)input.LT(1);
        if ( (input.LA(1)>=EQ && input.LA(1)<=NSAME) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }

        pushFollow(FOLLOW_relationalExpression_in_synpred269_ASCollector11553);
        relationalExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred269_ASCollector

    // $ANTLR start synpred281_ASCollector
    public final void synpred281_ASCollector_fragment() throws RecognitionException {   
        Token g=null;
        Token assign=null;
        Token eq=null;

        // ASCollector.g3:2282:7: ( (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )
        // ASCollector.g3:2282:7: (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression
        {
        // ASCollector.g3:2282:7: (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) )
        int alt182=2;
        int LA182_0 = input.LA(1);

        if ( (LA182_0==GT) ) {
            alt182=1;
        }
        else if ( (LA182_0==AS||(LA182_0>=IN && LA182_0<=INSTANCEOF)||LA182_0==IS||LA182_0==LT||LA182_0==LTE) ) {
            alt182=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 182, 0, input);

            throw nvae;
        }
        switch (alt182) {
            case 1 :
                // ASCollector.g3:2282:9: g= GT (assign= ASSIGN )?
                {
                g=(Token)match(input,GT,FOLLOW_GT_in_synpred281_ASCollector11644); if (state.failed) return ;
                // ASCollector.g3:2282:14: (assign= ASSIGN )?
                int alt181=2;
                int LA181_0 = input.LA(1);

                if ( (LA181_0==ASSIGN) ) {
                    alt181=1;
                }
                switch (alt181) {
                    case 1 :
                        // ASCollector.g3:2282:15: assign= ASSIGN
                        {
                        assign=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred281_ASCollector11649); if (state.failed) return ;

                        }
                        break;

                }


                }
                break;
            case 2 :
                // ASCollector.g3:2289:14: eq= ( IN | LT | LTE | INSTANCEOF | IS | AS )
                {
                eq=(Token)input.LT(1);
                if ( input.LA(1)==AS||(input.LA(1)>=IN && input.LA(1)<=INSTANCEOF)||input.LA(1)==IS||input.LA(1)==LT||input.LA(1)==LTE ) {
                    input.consume();
                    state.errorRecovery=false;state.failed=false;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    MismatchedSetException mse = new MismatchedSetException(null,input);
                    throw mse;
                }


                }
                break;

        }

        pushFollow(FOLLOW_shiftExpression_in_synpred281_ASCollector11719);
        shiftExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred281_ASCollector

    // $ANTLR start synpred290_ASCollector
    public final void synpred290_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2322:9: ( '>' '>' )
        // ASCollector.g3:2322:10: '>' '>'
        {
        match(input,GT,FOLLOW_GT_in_synpred290_ASCollector11943); if (state.failed) return ;
        match(input,GT,FOLLOW_GT_in_synpred290_ASCollector11945); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred290_ASCollector

    // $ANTLR start synpred291_ASCollector
    public final void synpred291_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2329:7: ( '>' '>' '>' )
        // ASCollector.g3:2329:8: '>' '>' '>'
        {
        match(input,GT,FOLLOW_GT_in_synpred291_ASCollector12006); if (state.failed) return ;
        match(input,GT,FOLLOW_GT_in_synpred291_ASCollector12008); if (state.failed) return ;
        match(input,GT,FOLLOW_GT_in_synpred291_ASCollector12010); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred291_ASCollector

    // $ANTLR start synpred292_ASCollector
    public final void synpred292_ASCollector_fragment() throws RecognitionException {   
        Token t1=null;
        Token t2=null;
        Token t3=null;
        ASCollectorParser.additiveExpression_return a1 = null;


        // ASCollector.g3:2314:7: ( (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression )
        // ASCollector.g3:2314:7: (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?) a1= additiveExpression
        {
        // ASCollector.g3:2314:7: (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?)
        int alt186=3;
        alt186 = dfa186.predict(input);
        switch (alt186) {
            case 1 :
                // ASCollector.g3:2315:8: t1= SHL
                {
                t1=(Token)match(input,SHL,FOLLOW_SHL_in_synpred292_ASCollector11903); if (state.failed) return ;

                }
                break;
            case 2 :
                // ASCollector.g3:2322:9: ( '>' '>' )=>t1= '>' t2= '>' {...}?
                {
                t1=(Token)match(input,GT,FOLLOW_GT_in_synpred292_ASCollector11951); if (state.failed) return ;
                t2=(Token)match(input,GT,FOLLOW_GT_in_synpred292_ASCollector11955); if (state.failed) return ;
                if ( !(( t1.getLine() == t2.getLine() && 
                          			t1.getCharPositionInLine() + 1 == t2.getCharPositionInLine() )) ) {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    throw new FailedPredicateException(input, "synpred292_ASCollector", " $t1.getLine() == $t2.getLine() && \r\n          \t\t\t$t1.getCharPositionInLine() + 1 == $t2.getCharPositionInLine() ");
                }

                }
                break;
            case 3 :
                // ASCollector.g3:2329:7: ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?
                {
                t1=(Token)match(input,GT,FOLLOW_GT_in_synpred292_ASCollector12016); if (state.failed) return ;
                t2=(Token)match(input,GT,FOLLOW_GT_in_synpred292_ASCollector12020); if (state.failed) return ;
                t3=(Token)match(input,GT,FOLLOW_GT_in_synpred292_ASCollector12025); if (state.failed) return ;
                if ( !(( t1.getLine() == t2.getLine() && 
                          			t1.getCharPositionInLine() + 1 == t2.getCharPositionInLine() &&
                          			t2.getLine() == t3.getLine() && 
                          			t2.getCharPositionInLine() + 1 == t3.getCharPositionInLine() )) ) {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    throw new FailedPredicateException(input, "synpred292_ASCollector", " $t1.getLine() == $t2.getLine() && \r\n          \t\t\t$t1.getCharPositionInLine() + 1 == $t2.getCharPositionInLine() &&\r\n          \t\t\t$t2.getLine() == $t3.getLine() && \r\n          \t\t\t$t2.getCharPositionInLine() + 1 == $t3.getCharPositionInLine() ");
                }

                }
                break;

        }

        pushFollow(FOLLOW_additiveExpression_in_synpred292_ASCollector12078);
        a1=additiveExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred292_ASCollector

    // $ANTLR start synpred294_ASCollector
    public final void synpred294_ASCollector_fragment() throws RecognitionException {   
        Token op=null;

        // ASCollector.g3:2343:36: (op= ( PLUS | SUB ) multiplicativeExpression )
        // ASCollector.g3:2343:36: op= ( PLUS | SUB ) multiplicativeExpression
        {
        op=(Token)input.LT(1);
        if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }

        pushFollow(FOLLOW_multiplicativeExpression_in_synpred294_ASCollector12120);
        multiplicativeExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred294_ASCollector

    // $ANTLR start synpred297_ASCollector
    public final void synpred297_ASCollector_fragment() throws RecognitionException {   
        Token op=null;

        // ASCollector.g3:2348:27: (op= ( STAR | DIV | MOD ) unaryExpression )
        // ASCollector.g3:2348:27: op= ( STAR | DIV | MOD ) unaryExpression
        {
        op=(Token)input.LT(1);
        if ( (input.LA(1)>=STAR && input.LA(1)<=MOD) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }

        pushFollow(FOLLOW_unaryExpression_in_synpred297_ASCollector12157);
        unaryExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred297_ASCollector

    // $ANTLR start synpred298_ASCollector
    public final void synpred298_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2353:9: ( postfixExpression )
        // ASCollector.g3:2353:9: postfixExpression
        {
        pushFollow(FOLLOW_postfixExpression_in_synpred298_ASCollector12180);
        postfixExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred298_ASCollector

    // $ANTLR start synpred300_ASCollector
    public final void synpred300_ASCollector_fragment() throws RecognitionException {   
        Token op=null;

        // ASCollector.g3:2354:8: (op= ( NOT | INV ) unaryExpression )
        // ASCollector.g3:2354:8: op= ( NOT | INV ) unaryExpression
        {
        op=(Token)input.LT(1);
        if ( (input.LA(1)>=NOT && input.LA(1)<=INV) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }

        pushFollow(FOLLOW_unaryExpression_in_synpred300_ASCollector12200);
        unaryExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred300_ASCollector

    // $ANTLR start synpred309_ASCollector
    public final void synpred309_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2367:32: ( postfixOp )
        // ASCollector.g3:2367:32: postfixOp
        {
        pushFollow(FOLLOW_postfixOp_in_synpred309_ASCollector12301);
        postfixOp();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred309_ASCollector

    // $ANTLR start synpred313_ASCollector
    public final void synpred313_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2389:7: ( arguments )
        // ASCollector.g3:2389:7: arguments
        {
        pushFollow(FOLLOW_arguments_in_synpred313_ASCollector12417);
        arguments();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred313_ASCollector

    // $ANTLR start synpred314_ASCollector
    public final void synpred314_ASCollector_fragment() throws RecognitionException {   
        Token L=null;
        Token R=null;

        // ASCollector.g3:2390:9: (L= LBRACK expression R= RBRACK )
        // ASCollector.g3:2390:9: L= LBRACK expression R= RBRACK
        {
        L=(Token)match(input,LBRACK,FOLLOW_LBRACK_in_synpred314_ASCollector12429); if (state.failed) return ;
        pushFollow(FOLLOW_expression_in_synpred314_ASCollector12432);
        expression();

        state._fsp--;
        if (state.failed) return ;
        R=(Token)match(input,RBRACK,FOLLOW_RBRACK_in_synpred314_ASCollector12436); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred314_ASCollector

    // $ANTLR start synpred315_ASCollector
    public final void synpred315_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2393:9: ( XML_ELLIPSIS eitherIdentifier )
        // ASCollector.g3:2393:9: XML_ELLIPSIS eitherIdentifier
        {
        match(input,XML_ELLIPSIS,FOLLOW_XML_ELLIPSIS_in_synpred315_ASCollector12449); if (state.failed) return ;
        pushFollow(FOLLOW_eitherIdentifier_in_synpred315_ASCollector12451);
        eitherIdentifier();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred315_ASCollector

    // $ANTLR start synpred317_ASCollector
    public final void synpred317_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2394:9: ( DOT ( eitherIdentifier | parExpression ) )
        // ASCollector.g3:2394:9: DOT ( eitherIdentifier | parExpression )
        {
        match(input,DOT,FOLLOW_DOT_in_synpred317_ASCollector12461); if (state.failed) return ;
        // ASCollector.g3:2394:13: ( eitherIdentifier | parExpression )
        int alt187=2;
        int LA187_0 = input.LA(1);

        if ( ((LA187_0>=AS && LA187_0<=STATIC)||LA187_0==STAR||LA187_0==XML_AT||LA187_0==IDENTIFIER) ) {
            alt187=1;
        }
        else if ( (LA187_0==LPAREN) ) {
            alt187=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 187, 0, input);

            throw nvae;
        }
        switch (alt187) {
            case 1 :
                // ASCollector.g3:2394:14: eitherIdentifier
                {
                pushFollow(FOLLOW_eitherIdentifier_in_synpred317_ASCollector12464);
                eitherIdentifier();

                state._fsp--;
                if (state.failed) return ;

                }
                break;
            case 2 :
                // ASCollector.g3:2394:33: parExpression
                {
                pushFollow(FOLLOW_parExpression_in_synpred317_ASCollector12468);
                parExpression();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        }
    }
    // $ANTLR end synpred317_ASCollector

    // $ANTLR start synpred318_ASCollector
    public final void synpred318_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2395:9: ( typePostfixSyntax )
        // ASCollector.g3:2395:9: typePostfixSyntax
        {
        pushFollow(FOLLOW_typePostfixSyntax_in_synpred318_ASCollector12479);
        typePostfixSyntax();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred318_ASCollector

    // $ANTLR start synpred319_ASCollector
    public final void synpred319_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2396:9: ( XML_NS_OP expression )
        // ASCollector.g3:2396:9: XML_NS_OP expression
        {
        match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_synpred319_ASCollector12489); if (state.failed) return ;
        pushFollow(FOLLOW_expression_in_synpred319_ASCollector12491);
        expression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred319_ASCollector

    // $ANTLR start synpred320_ASCollector
    public final void synpred320_ASCollector_fragment() throws RecognitionException {   
        Token I=null;

        // ASCollector.g3:2401:4: (I= IDENTIFIER )
        // ASCollector.g3:2401:4: I= IDENTIFIER
        {
        I=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred320_ASCollector12520); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred320_ASCollector

    // $ANTLR start synpred321_ASCollector
    public final void synpred321_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2402:5: ( xmlPropertyIdentifier )
        // ASCollector.g3:2402:5: xmlPropertyIdentifier
        {
        pushFollow(FOLLOW_xmlPropertyIdentifier_in_synpred321_ASCollector12529);
        xmlPropertyIdentifier();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred321_ASCollector

    // $ANTLR start synpred383_ASCollector
    public final void synpred383_ASCollector_fragment() throws RecognitionException {   
        Token T=null;

        // ASCollector.g3:2517:9: (T= THIS )
        // ASCollector.g3:2517:9: T= THIS
        {
        T=(Token)match(input,THIS,FOLLOW_THIS_in_synpred383_ASCollector13508); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred383_ASCollector

    // $ANTLR start synpred384_ASCollector
    public final void synpred384_ASCollector_fragment() throws RecognitionException {   
        Token S=null;

        // ASCollector.g3:2518:9: (S= SUPER )
        // ASCollector.g3:2518:9: S= SUPER
        {
        S=(Token)match(input,SUPER,FOLLOW_SUPER_in_synpred384_ASCollector13521); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred384_ASCollector

    // $ANTLR start synpred385_ASCollector
    public final void synpred385_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2519:9: ( literal )
        // ASCollector.g3:2519:9: literal
        {
        pushFollow(FOLLOW_literal_in_synpred385_ASCollector13532);
        literal();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred385_ASCollector

    // $ANTLR start synpred388_ASCollector
    public final void synpred388_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2522:10: ( identifierLiteral XML_NS_OP )
        // ASCollector.g3:2522:10: identifierLiteral XML_NS_OP
        {
        pushFollow(FOLLOW_identifierLiteral_in_synpred388_ASCollector13568);
        identifierLiteral();

        state._fsp--;
        if (state.failed) return ;
        match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_synpred388_ASCollector13570); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred388_ASCollector

    // $ANTLR start synpred389_ASCollector
    public final void synpred389_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2522:9: ( ( identifierLiteral XML_NS_OP )? identifierLiteral )
        // ASCollector.g3:2522:9: ( identifierLiteral XML_NS_OP )? identifierLiteral
        {
        // ASCollector.g3:2522:9: ( identifierLiteral XML_NS_OP )?
        int alt189=2;
        int LA189_0 = input.LA(1);

        if ( (LA189_0==IDENTIFIER) ) {
            int LA189_1 = input.LA(2);

            if ( (LA189_1==XML_NS_OP) ) {
                alt189=1;
            }
        }
        else if ( (LA189_0==NATIVE||LA189_0==TO||(LA189_0>=EACH && LA189_0<=NAMESPACE)||(LA189_0>=DYNAMIC && LA189_0<=STATIC)) ) {
            int LA189_2 = input.LA(2);

            if ( (LA189_2==XML_NS_OP) ) {
                alt189=1;
            }
        }
        switch (alt189) {
            case 1 :
                // ASCollector.g3:2522:10: identifierLiteral XML_NS_OP
                {
                pushFollow(FOLLOW_identifierLiteral_in_synpred389_ASCollector13568);
                identifierLiteral();

                state._fsp--;
                if (state.failed) return ;
                match(input,XML_NS_OP,FOLLOW_XML_NS_OP_in_synpred389_ASCollector13570); if (state.failed) return ;

                }
                break;

        }

        pushFollow(FOLLOW_identifierLiteral_in_synpred389_ASCollector13574);
        identifierLiteral();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred389_ASCollector

    // $ANTLR start synpred390_ASCollector
    public final void synpred390_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2523:9: ( xmlPrimaryExpression )
        // ASCollector.g3:2523:9: xmlPrimaryExpression
        {
        pushFollow(FOLLOW_xmlPrimaryExpression_in_synpred390_ASCollector13585);
        xmlPrimaryExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred390_ASCollector

    // $ANTLR start synpred392_ASCollector
    public final void synpred392_ASCollector_fragment() throws RecognitionException {   
        // ASCollector.g3:2525:21: ( arrayLiteral )
        // ASCollector.g3:2525:21: arrayLiteral
        {
        pushFollow(FOLLOW_arrayLiteral_in_synpred392_ASCollector13613);
        arrayLiteral();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred392_ASCollector

    // Delegated rules

    public final boolean synpred191_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred191_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred260_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred260_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred136_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred136_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred315_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred315_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred73_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred73_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred109_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred109_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred206_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred206_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred290_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred290_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred210_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred210_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred269_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred269_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred105_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred105_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred139_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred139_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred75_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred75_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred144_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred144_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred124_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred124_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred192_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred192_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred106_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred106_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred388_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred388_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred101_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred101_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred9_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred9_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred170_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred170_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred249_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred249_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred125_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred125_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred100_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred100_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred107_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred107_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred169_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred169_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred185_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred185_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred258_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred258_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred300_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred300_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred74_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred74_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred188_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred188_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred239_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred239_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred383_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred383_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred195_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred195_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred180_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred180_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred384_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred384_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred385_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred385_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred99_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred99_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred196_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred196_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred248_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred248_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred182_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred182_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred138_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred138_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred186_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred186_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred390_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred390_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred184_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred184_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred309_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred309_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred254_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred254_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred262_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred262_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred313_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred313_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred320_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred320_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred319_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred319_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred318_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred318_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred68_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred68_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred314_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred314_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred202_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred202_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred98_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred98_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred194_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred194_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred110_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred110_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred102_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred102_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred317_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred317_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred69_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred69_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred297_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred297_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred240_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred240_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred221_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred221_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred193_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred193_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred143_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred143_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred208_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred208_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred153_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred153_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred190_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred190_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred189_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred189_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred321_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred321_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred298_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred298_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred281_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred281_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred222_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred222_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred292_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred292_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred108_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred108_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred187_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred187_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred389_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred389_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred197_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred197_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred198_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred198_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred291_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred291_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred199_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred199_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred264_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred264_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred168_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred168_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred140_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred140_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred141_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred141_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred237_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred237_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred97_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred97_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred145_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred145_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred181_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred181_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred183_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred183_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred294_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred294_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred256_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred256_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred392_ASCollector() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred392_ASCollector_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA7 dfa7 = new DFA7(this);
    protected DFA33 dfa33 = new DFA33(this);
    protected DFA36 dfa36 = new DFA36(this);
    protected DFA48 dfa48 = new DFA48(this);
    protected DFA58 dfa58 = new DFA58(this);
    protected DFA60 dfa60 = new DFA60(this);
    protected DFA80 dfa80 = new DFA80(this);
    protected DFA82 dfa82 = new DFA82(this);
    protected DFA92 dfa92 = new DFA92(this);
    protected DFA120 dfa120 = new DFA120(this);
    protected DFA121 dfa121 = new DFA121(this);
    protected DFA122 dfa122 = new DFA122(this);
    protected DFA139 dfa139 = new DFA139(this);
    protected DFA143 dfa143 = new DFA143(this);
    protected DFA147 dfa147 = new DFA147(this);
    protected DFA151 dfa151 = new DFA151(this);
    protected DFA161 dfa161 = new DFA161(this);
    protected DFA160 dfa160 = new DFA160(this);
    protected DFA186 dfa186 = new DFA186(this);
    static final String DFA7_eotS =
        "\133\uffff";
    static final String DFA7_eofS =
        "\1\1\132\uffff";
    static final String DFA7_minS =
        "\1\4\3\uffff\1\0\21\uffff\1\0\77\uffff\1\0\4\uffff";
    static final String DFA7_maxS =
        "\1\u0092\3\uffff\1\0\21\uffff\1\0\77\uffff\1\0\4\uffff";
    static final String DFA7_acceptS =
        "\1\uffff\1\2\130\uffff\1\1";
    static final String DFA7_specialS =
        "\4\uffff\1\0\21\uffff\1\1\77\uffff\1\2\4\uffff}>";
    static final String[] DFA7_transitionS = {
            "\75\1\1\4\4\1\1\uffff\5\1\1\26\6\1\2\uffff\10\1\1\126\6\1\2"+
            "\uffff\5\1\1\uffff\2\1\1\uffff\3\1\16\uffff\2\1\2\uffff\1\1"+
            "\4\uffff\1\1\2\uffff\1\1\1\uffff\1\1\1\uffff\3\1",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "()* loopback of 845:67: ({...}? => ( SUB | DOT | COLON ) {...}? => ( IDENTIFIER | allKeywords ) )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA7_4 = input.LA(1);

                         
                        int index7_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( ((synpred9_ASCollector()&&(!promoteWhitespace()))) ) {s = 90;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index7_4);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA7_22 = input.LA(1);

                         
                        int index7_22 = input.index();
                        input.rewind();
                        s = -1;
                        if ( ((synpred9_ASCollector()&&(!promoteWhitespace()))) ) {s = 90;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index7_22);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA7_86 = input.LA(1);

                         
                        int index7_86 = input.index();
                        input.rewind();
                        s = -1;
                        if ( ((synpred9_ASCollector()&&(!promoteWhitespace()))) ) {s = 90;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index7_86);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 7, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA33_eotS =
        "\71\uffff";
    static final String DFA33_eofS =
        "\1\1\70\uffff";
    static final String DFA33_minS =
        "\1\4\2\uffff\10\0\1\uffff\5\0\50\uffff";
    static final String DFA33_maxS =
        "\1\u0092\2\uffff\10\0\1\uffff\5\0\50\uffff";
    static final String DFA33_acceptS =
        "\1\uffff\1\7\11\uffff\1\4\50\uffff\1\1\1\2\1\3\1\6\1\5";
    static final String DFA33_specialS =
        "\3\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\uffff\1\10\1\11\1\12"+
        "\1\13\1\14\50\uffff}>";
    static final String[] DFA33_transitionS = {
            "\5\13\1\10\1\13\1\20\7\13\1\12\2\13\1\17\3\13\1\6\1\13\1\4"+
            "\3\13\3\6\5\13\1\11\3\13\1\16\1\7\3\13\3\11\1\5\1\15\4\4\2\13"+
            "\1\1\1\13\1\uffff\1\14\3\uffff\1\13\7\uffff\3\13\2\uffff\2\13"+
            "\6\uffff\2\13\26\uffff\2\13\16\uffff\2\13\2\uffff\1\13\4\uffff"+
            "\1\13\2\uffff\1\13\1\uffff\1\3\1\uffff\3\13",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA33_eot = DFA.unpackEncodedString(DFA33_eotS);
    static final short[] DFA33_eof = DFA.unpackEncodedString(DFA33_eofS);
    static final char[] DFA33_min = DFA.unpackEncodedStringToUnsignedChars(DFA33_minS);
    static final char[] DFA33_max = DFA.unpackEncodedStringToUnsignedChars(DFA33_maxS);
    static final short[] DFA33_accept = DFA.unpackEncodedString(DFA33_acceptS);
    static final short[] DFA33_special = DFA.unpackEncodedString(DFA33_specialS);
    static final short[][] DFA33_transition;

    static {
        int numStates = DFA33_transitionS.length;
        DFA33_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA33_transition[i] = DFA.unpackEncodedString(DFA33_transitionS[i]);
        }
    }

    class DFA33 extends DFA {

        public DFA33(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 33;
            this.eot = DFA33_eot;
            this.eof = DFA33_eof;
            this.min = DFA33_min;
            this.max = DFA33_max;
            this.accept = DFA33_accept;
            this.special = DFA33_special;
            this.transition = DFA33_transition;
        }
        public String getDescription() {
            return "()* loopback of 1105:3: ( conditionalCompilerOption LCURLY mxmlEmbedded RCURLY | propertyDeclaration | functionDeclaration[true] | statement | directive | interfaceFunctionDeclaration[true] )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA33_3 = input.LA(1);

                         
                        int index33_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred97_ASCollector()) ) {s = 52;}

                        else if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred99_ASCollector()) ) {s = 54;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred102_ASCollector()) ) {s = 55;}

                         
                        input.seek(index33_3);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA33_4 = input.LA(1);

                         
                        int index33_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred97_ASCollector()) ) {s = 52;}

                        else if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred99_ASCollector()) ) {s = 54;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred102_ASCollector()) ) {s = 55;}

                         
                        input.seek(index33_4);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA33_5 = input.LA(1);

                         
                        int index33_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred97_ASCollector()) ) {s = 52;}

                        else if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred99_ASCollector()) ) {s = 54;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred102_ASCollector()) ) {s = 55;}

                         
                        input.seek(index33_5);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA33_6 = input.LA(1);

                         
                        int index33_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred99_ASCollector()) ) {s = 54;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred102_ASCollector()) ) {s = 55;}

                         
                        input.seek(index33_6);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA33_7 = input.LA(1);

                         
                        int index33_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                         
                        input.seek(index33_7);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA33_8 = input.LA(1);

                         
                        int index33_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                         
                        input.seek(index33_8);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA33_9 = input.LA(1);

                         
                        int index33_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred97_ASCollector()) ) {s = 52;}

                        else if ( (synpred98_ASCollector()) ) {s = 53;}

                        else if ( (synpred99_ASCollector()) ) {s = 54;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred102_ASCollector()) ) {s = 55;}

                         
                        input.seek(index33_9);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA33_10 = input.LA(1);

                         
                        int index33_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred99_ASCollector()) ) {s = 54;}

                        else if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred102_ASCollector()) ) {s = 55;}

                         
                        input.seek(index33_10);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA33_12 = input.LA(1);

                         
                        int index33_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred101_ASCollector()) ) {s = 56;}

                         
                        input.seek(index33_12);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA33_13 = input.LA(1);

                         
                        int index33_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred101_ASCollector()) ) {s = 56;}

                         
                        input.seek(index33_13);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA33_14 = input.LA(1);

                         
                        int index33_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred101_ASCollector()) ) {s = 56;}

                         
                        input.seek(index33_14);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA33_15 = input.LA(1);

                         
                        int index33_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred101_ASCollector()) ) {s = 56;}

                         
                        input.seek(index33_15);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA33_16 = input.LA(1);

                         
                        int index33_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred100_ASCollector()) ) {s = 11;}

                        else if ( (synpred101_ASCollector()) ) {s = 56;}

                         
                        input.seek(index33_16);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 33, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA36_eotS =
        "\72\uffff";
    static final String DFA36_eofS =
        "\72\uffff";
    static final String DFA36_minS =
        "\1\4\17\0\52\uffff";
    static final String DFA36_maxS =
        "\1\u0092\17\0\52\uffff";
    static final String DFA36_acceptS =
        "\20\uffff\1\7\43\uffff\1\1\1\2\1\3\1\4\1\5\1\6";
    static final String DFA36_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"+
        "\14\1\15\1\16\52\uffff}>";
    static final String[] DFA36_transitionS = {
            "\4\20\1\6\1\10\1\20\1\17\7\20\1\12\2\20\1\16\2\20\1\5\1\4\1"+
            "\20\1\2\3\20\3\4\5\20\1\11\3\20\1\15\1\7\3\20\3\11\1\3\1\14"+
            "\4\2\2\20\1\uffff\1\20\1\uffff\1\13\3\uffff\1\20\7\uffff\3\20"+
            "\2\uffff\2\20\6\uffff\2\20\26\uffff\2\20\16\uffff\2\20\2\uffff"+
            "\1\20\4\uffff\1\20\2\uffff\1\20\1\uffff\1\1\1\uffff\3\20",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS);
    static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS);
    static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS);
    static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS);
    static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS);
    static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS);
    static final short[][] DFA36_transition;

    static {
        int numStates = DFA36_transitionS.length;
        DFA36_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA36_transition[i] = DFA.unpackEncodedString(DFA36_transitionS[i]);
        }
    }

    class DFA36 extends DFA {

        public DFA36(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 36;
            this.eot = DFA36_eot;
            this.eof = DFA36_eof;
            this.min = DFA36_min;
            this.max = DFA36_max;
            this.accept = DFA36_accept;
            this.special = DFA36_special;
            this.transition = DFA36_transition;
        }
        public String getDescription() {
            return "1110:1: packageElement : ( conditionalCompilerOption LCURLY ( packageElement )* RCURLY | classOrInterfaceDecl | propertyDeclaration | functionDeclaration[true] | interfaceFunctionDeclaration[true] | directive | statement );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA36_1 = input.LA(1);

                         
                        int index36_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred105_ASCollector()) ) {s = 52;}

                        else if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (synpred108_ASCollector()) ) {s = 55;}

                        else if ( (synpred109_ASCollector()) ) {s = 56;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA36_2 = input.LA(1);

                         
                        int index36_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred105_ASCollector()) ) {s = 52;}

                        else if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (synpred108_ASCollector()) ) {s = 55;}

                        else if ( (synpred109_ASCollector()) ) {s = 56;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA36_3 = input.LA(1);

                         
                        int index36_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred105_ASCollector()) ) {s = 52;}

                        else if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (synpred108_ASCollector()) ) {s = 55;}

                        else if ( (synpred109_ASCollector()) ) {s = 56;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA36_4 = input.LA(1);

                         
                        int index36_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (synpred108_ASCollector()) ) {s = 55;}

                        else if ( (synpred109_ASCollector()) ) {s = 56;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA36_5 = input.LA(1);

                         
                        int index36_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA36_6 = input.LA(1);

                         
                        int index36_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA36_7 = input.LA(1);

                         
                        int index36_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA36_8 = input.LA(1);

                         
                        int index36_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA36_9 = input.LA(1);

                         
                        int index36_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred105_ASCollector()) ) {s = 52;}

                        else if ( (synpred106_ASCollector()) ) {s = 53;}

                        else if ( (synpred107_ASCollector()) ) {s = 54;}

                        else if ( (synpred108_ASCollector()) ) {s = 55;}

                        else if ( (synpred109_ASCollector()) ) {s = 56;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA36_10 = input.LA(1);

                         
                        int index36_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred108_ASCollector()) ) {s = 55;}

                        else if ( (synpred109_ASCollector()) ) {s = 56;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_10);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA36_11 = input.LA(1);

                         
                        int index36_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred110_ASCollector()) ) {s = 57;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_11);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA36_12 = input.LA(1);

                         
                        int index36_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred110_ASCollector()) ) {s = 57;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_12);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA36_13 = input.LA(1);

                         
                        int index36_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred110_ASCollector()) ) {s = 57;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_13);
                        if ( s>=0 ) return s;
                        break;
                    case 13 : 
                        int LA36_14 = input.LA(1);

                         
                        int index36_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred110_ASCollector()) ) {s = 57;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_14);
                        if ( s>=0 ) return s;
                        break;
                    case 14 : 
                        int LA36_15 = input.LA(1);

                         
                        int index36_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred110_ASCollector()) ) {s = 57;}

                        else if ( (true) ) {s = 16;}

                         
                        input.seek(index36_15);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 36, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA48_eotS =
        "\14\uffff";
    static final String DFA48_eofS =
        "\14\uffff";
    static final String DFA48_minS =
        "\1\4\5\0\6\uffff";
    static final String DFA48_maxS =
        "\1\u008e\5\0\6\uffff";
    static final String DFA48_acceptS =
        "\6\uffff\1\2\4\uffff\1\1";
    static final String DFA48_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\6\uffff}>";
    static final String[] DFA48_transitionS = {
            "\30\3\1\4\13\3\1\4\10\3\4\4\1\3\4\4\21\uffff\2\6\1\5\42\uffff"+
            "\1\2\17\uffff\2\6\7\uffff\1\6\2\uffff\1\6\1\uffff\1\1",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA48_eot = DFA.unpackEncodedString(DFA48_eotS);
    static final short[] DFA48_eof = DFA.unpackEncodedString(DFA48_eofS);
    static final char[] DFA48_min = DFA.unpackEncodedStringToUnsignedChars(DFA48_minS);
    static final char[] DFA48_max = DFA.unpackEncodedStringToUnsignedChars(DFA48_maxS);
    static final short[] DFA48_accept = DFA.unpackEncodedString(DFA48_acceptS);
    static final short[] DFA48_special = DFA.unpackEncodedString(DFA48_specialS);
    static final short[][] DFA48_transition;

    static {
        int numStates = DFA48_transitionS.length;
        DFA48_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA48_transition[i] = DFA.unpackEncodedString(DFA48_transitionS[i]);
        }
    }

    class DFA48 extends DFA {

        public DFA48(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 48;
            this.eot = DFA48_eot;
            this.eof = DFA48_eof;
            this.min = DFA48_min;
            this.max = DFA48_max;
            this.accept = DFA48_accept;
            this.special = DFA48_special;
            this.transition = DFA48_transition;
        }
        public String getDescription() {
            return "1295:2: ( eitherIdentifier E= ASSIGN )?";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA48_1 = input.LA(1);

                         
                        int index48_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred125_ASCollector()) ) {s = 11;}

                        else if ( (true) ) {s = 6;}

                         
                        input.seek(index48_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA48_2 = input.LA(1);

                         
                        int index48_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred125_ASCollector()) ) {s = 11;}

                        else if ( (true) ) {s = 6;}

                         
                        input.seek(index48_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA48_3 = input.LA(1);

                         
                        int index48_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred125_ASCollector()) ) {s = 11;}

                        else if ( (true) ) {s = 6;}

                         
                        input.seek(index48_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA48_4 = input.LA(1);

                         
                        int index48_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred125_ASCollector()) ) {s = 11;}

                        else if ( (true) ) {s = 6;}

                         
                        input.seek(index48_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA48_5 = input.LA(1);

                         
                        int index48_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred125_ASCollector()) ) {s = 11;}

                        else if ( (true) ) {s = 6;}

                         
                        input.seek(index48_5);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 48, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA58_eotS =
        "\66\uffff";
    static final String DFA58_eofS =
        "\66\uffff";
    static final String DFA58_minS =
        "\1\4\15\0\50\uffff";
    static final String DFA58_maxS =
        "\1\u0092\15\0\50\uffff";
    static final String DFA58_acceptS =
        "\16\uffff\1\5\43\uffff\1\1\1\2\1\3\1\4";
    static final String DFA58_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"+
        "\14\50\uffff}>";
    static final String[] DFA58_transitionS = {
            "\5\16\1\6\1\16\1\15\7\16\1\10\2\16\1\14\3\16\1\4\1\16\1\2\3"+
            "\16\3\4\5\16\1\7\3\16\1\13\1\5\3\16\3\7\1\3\1\12\4\2\2\16\1"+
            "\uffff\1\16\1\uffff\1\11\3\uffff\1\16\7\uffff\3\16\2\uffff\2"+
            "\16\6\uffff\2\16\26\uffff\2\16\16\uffff\2\16\2\uffff\1\16\4"+
            "\uffff\1\16\2\uffff\1\16\1\uffff\1\1\1\uffff\3\16",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA58_eot = DFA.unpackEncodedString(DFA58_eotS);
    static final short[] DFA58_eof = DFA.unpackEncodedString(DFA58_eofS);
    static final char[] DFA58_min = DFA.unpackEncodedStringToUnsignedChars(DFA58_minS);
    static final char[] DFA58_max = DFA.unpackEncodedStringToUnsignedChars(DFA58_maxS);
    static final short[] DFA58_accept = DFA.unpackEncodedString(DFA58_acceptS);
    static final short[] DFA58_special = DFA.unpackEncodedString(DFA58_specialS);
    static final short[][] DFA58_transition;

    static {
        int numStates = DFA58_transitionS.length;
        DFA58_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA58_transition[i] = DFA.unpackEncodedString(DFA58_transitionS[i]);
        }
    }

    class DFA58 extends DFA {

        public DFA58(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 58;
            this.eot = DFA58_eot;
            this.eof = DFA58_eof;
            this.min = DFA58_min;
            this.max = DFA58_max;
            this.accept = DFA58_accept;
            this.special = DFA58_special;
            this.transition = DFA58_transition;
        }
        public String getDescription() {
            return "1373:1: classBodyElement : ( ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( classBodyElement )* RCURLY | propertyDeclaration | functionDeclaration[true] | directive | statement );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA58_1 = input.LA(1);

                         
                        int index58_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred136_ASCollector()) ) {s = 50;}

                        else if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (synpred139_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA58_2 = input.LA(1);

                         
                        int index58_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred136_ASCollector()) ) {s = 50;}

                        else if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (synpred139_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA58_3 = input.LA(1);

                         
                        int index58_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred136_ASCollector()) ) {s = 50;}

                        else if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (synpred139_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA58_4 = input.LA(1);

                         
                        int index58_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (synpred139_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA58_5 = input.LA(1);

                         
                        int index58_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA58_6 = input.LA(1);

                         
                        int index58_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA58_7 = input.LA(1);

                         
                        int index58_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred136_ASCollector()) ) {s = 50;}

                        else if ( (synpred138_ASCollector()) ) {s = 51;}

                        else if ( (synpred139_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA58_8 = input.LA(1);

                         
                        int index58_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred139_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA58_9 = input.LA(1);

                         
                        int index58_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred140_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA58_10 = input.LA(1);

                         
                        int index58_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred140_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_10);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA58_11 = input.LA(1);

                         
                        int index58_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred140_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_11);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA58_12 = input.LA(1);

                         
                        int index58_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred140_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_12);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA58_13 = input.LA(1);

                         
                        int index58_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred140_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index58_13);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 58, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA60_eotS =
        "\66\uffff";
    static final String DFA60_eofS =
        "\66\uffff";
    static final String DFA60_minS =
        "\1\4\15\0\50\uffff";
    static final String DFA60_maxS =
        "\1\u0092\15\0\50\uffff";
    static final String DFA60_acceptS =
        "\16\uffff\1\5\43\uffff\1\1\1\2\1\3\1\4";
    static final String DFA60_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"+
        "\14\50\uffff}>";
    static final String[] DFA60_transitionS = {
            "\5\16\1\6\1\16\1\15\7\16\1\10\2\16\1\14\3\16\1\4\1\16\1\2\3"+
            "\16\3\4\5\16\1\7\3\16\1\13\1\5\3\16\3\7\1\3\1\12\4\2\2\16\1"+
            "\uffff\1\16\1\uffff\1\11\3\uffff\1\16\7\uffff\3\16\2\uffff\2"+
            "\16\6\uffff\2\16\26\uffff\2\16\16\uffff\2\16\2\uffff\1\16\4"+
            "\uffff\1\16\2\uffff\1\16\1\uffff\1\1\1\uffff\3\16",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA60_eot = DFA.unpackEncodedString(DFA60_eotS);
    static final short[] DFA60_eof = DFA.unpackEncodedString(DFA60_eofS);
    static final char[] DFA60_min = DFA.unpackEncodedStringToUnsignedChars(DFA60_minS);
    static final char[] DFA60_max = DFA.unpackEncodedStringToUnsignedChars(DFA60_maxS);
    static final short[] DFA60_accept = DFA.unpackEncodedString(DFA60_acceptS);
    static final short[] DFA60_special = DFA.unpackEncodedString(DFA60_specialS);
    static final short[][] DFA60_transition;

    static {
        int numStates = DFA60_transitionS.length;
        DFA60_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA60_transition[i] = DFA.unpackEncodedString(DFA60_transitionS[i]);
        }
    }

    class DFA60 extends DFA {

        public DFA60(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 60;
            this.eot = DFA60_eot;
            this.eof = DFA60_eof;
            this.min = DFA60_min;
            this.max = DFA60_max;
            this.accept = DFA60_accept;
            this.special = DFA60_special;
            this.transition = DFA60_transition;
        }
        public String getDescription() {
            return "1378:1: interfaceElement : ( ( conditionalCompilerOption LCURLY )=> conditionalCompilerOption LCURLY ( interfaceElement )* RCURLY | propertyDeclaration | interfaceFunctionDeclaration[true] | directive | statement );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA60_1 = input.LA(1);

                         
                        int index60_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred141_ASCollector()) ) {s = 50;}

                        else if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (synpred144_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA60_2 = input.LA(1);

                         
                        int index60_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred141_ASCollector()) ) {s = 50;}

                        else if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (synpred144_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA60_3 = input.LA(1);

                         
                        int index60_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred141_ASCollector()) ) {s = 50;}

                        else if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (synpred144_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA60_4 = input.LA(1);

                         
                        int index60_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (synpred144_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA60_5 = input.LA(1);

                         
                        int index60_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA60_6 = input.LA(1);

                         
                        int index60_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA60_7 = input.LA(1);

                         
                        int index60_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred141_ASCollector()) ) {s = 50;}

                        else if ( (synpred143_ASCollector()) ) {s = 51;}

                        else if ( (synpred144_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA60_8 = input.LA(1);

                         
                        int index60_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred144_ASCollector()) ) {s = 52;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA60_9 = input.LA(1);

                         
                        int index60_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred145_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA60_10 = input.LA(1);

                         
                        int index60_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred145_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_10);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA60_11 = input.LA(1);

                         
                        int index60_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred145_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_11);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA60_12 = input.LA(1);

                         
                        int index60_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred145_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_12);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA60_13 = input.LA(1);

                         
                        int index60_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred145_ASCollector()) ) {s = 53;}

                        else if ( (true) ) {s = 14;}

                         
                        input.seek(index60_13);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 60, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA80_eotS =
        "\64\uffff";
    static final String DFA80_eofS =
        "\64\uffff";
    static final String DFA80_minS =
        "\1\4\1\uffff\2\0\6\uffff\1\0\30\uffff\1\0\12\uffff\1\0\2\uffff"+
        "\1\0\2\uffff";
    static final String DFA80_maxS =
        "\1\u0092\1\uffff\2\0\6\uffff\1\0\30\uffff\1\0\12\uffff\1\0\2\uffff"+
        "\1\0\2\uffff";
    static final String DFA80_acceptS =
        "\1\uffff\1\3\2\uffff\1\1\56\uffff\1\2";
    static final String DFA80_specialS =
        "\2\uffff\1\0\1\1\6\uffff\1\2\30\uffff\1\3\12\uffff\1\4\2\uffff"+
        "\1\5\2\uffff}>";
    static final String[] DFA80_transitionS = {
            "\17\4\1\43\6\4\1\56\1\4\1\12\3\4\3\56\5\4\1\61\10\4\3\61\1"+
            "\3\1\4\4\12\2\4\1\1\1\4\1\uffff\1\4\3\uffff\1\4\7\uffff\3\4"+
            "\2\uffff\2\4\6\uffff\2\4\26\uffff\2\4\16\uffff\2\4\2\uffff\1"+
            "\4\4\uffff\1\4\2\uffff\1\4\1\uffff\1\2\1\uffff\3\4",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA80_eot = DFA.unpackEncodedString(DFA80_eotS);
    static final short[] DFA80_eof = DFA.unpackEncodedString(DFA80_eofS);
    static final char[] DFA80_min = DFA.unpackEncodedStringToUnsignedChars(DFA80_minS);
    static final char[] DFA80_max = DFA.unpackEncodedStringToUnsignedChars(DFA80_maxS);
    static final short[] DFA80_accept = DFA.unpackEncodedString(DFA80_acceptS);
    static final short[] DFA80_special = DFA.unpackEncodedString(DFA80_specialS);
    static final short[][] DFA80_transition;

    static {
        int numStates = DFA80_transitionS.length;
        DFA80_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA80_transition[i] = DFA.unpackEncodedString(DFA80_transitionS[i]);
        }
    }

    class DFA80 extends DFA {

        public DFA80(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 80;
            this.eot = DFA80_eot;
            this.eof = DFA80_eof;
            this.min = DFA80_min;
            this.max = DFA80_max;
            this.accept = DFA80_accept;
            this.special = DFA80_special;
            this.transition = DFA80_transition;
        }
        public String getDescription() {
            return "()* loopback of 1622:7: ( statement | functionDeclaration[false] )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA80_2 = input.LA(1);

                         
                        int index80_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred168_ASCollector()) ) {s = 4;}

                        else if ( (synpred169_ASCollector()) ) {s = 51;}

                         
                        input.seek(index80_2);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA80_3 = input.LA(1);

                         
                        int index80_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred168_ASCollector()) ) {s = 4;}

                        else if ( (synpred169_ASCollector()) ) {s = 51;}

                         
                        input.seek(index80_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA80_10 = input.LA(1);

                         
                        int index80_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred168_ASCollector()) ) {s = 4;}

                        else if ( (synpred169_ASCollector()) ) {s = 51;}

                         
                        input.seek(index80_10);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA80_35 = input.LA(1);

                         
                        int index80_35 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred168_ASCollector()) ) {s = 4;}

                        else if ( (synpred169_ASCollector()) ) {s = 51;}

                         
                        input.seek(index80_35);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA80_46 = input.LA(1);

                         
                        int index80_46 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred168_ASCollector()) ) {s = 4;}

                        else if ( (synpred169_ASCollector()) ) {s = 51;}

                         
                        input.seek(index80_46);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA80_49 = input.LA(1);

                         
                        int index80_49 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred168_ASCollector()) ) {s = 4;}

                        else if ( (synpred169_ASCollector()) ) {s = 51;}

                         
                        input.seek(index80_49);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 80, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA82_eotS =
        "\103\uffff";
    static final String DFA82_eofS =
        "\103\uffff";
    static final String DFA82_minS =
        "\1\4\26\0\54\uffff";
    static final String DFA82_maxS =
        "\1\u0092\26\0\54\uffff";
    static final String DFA82_acceptS =
        "\27\uffff\1\24\27\uffff\1\25\1\1\1\21\1\23\1\3\1\2\1\4\1\5\1\6"+
        "\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\22";
    static final String DFA82_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"+
        "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\54\uffff}>";
    static final String[] DFA82_transitionS = {
            "\1\27\1\17\3\27\1\12\1\20\1\10\1\27\1\22\4\27\1\21\1\27\1\24"+
            "\1\27\1\7\5\27\1\11\6\27\1\16\1\27\1\14\1\27\1\26\1\11\1\27"+
            "\1\13\1\27\1\6\1\25\1\27\1\23\1\15\3\11\1\2\1\5\4\11\1\57\1"+
            "\3\1\uffff\1\27\1\uffff\1\4\3\uffff\1\27\7\uffff\3\27\2\uffff"+
            "\2\27\6\uffff\2\27\26\uffff\2\27\16\uffff\2\27\2\uffff\1\27"+
            "\4\uffff\1\27\2\uffff\1\27\1\uffff\1\1\1\uffff\3\27",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA82_eot = DFA.unpackEncodedString(DFA82_eotS);
    static final short[] DFA82_eof = DFA.unpackEncodedString(DFA82_eofS);
    static final char[] DFA82_min = DFA.unpackEncodedStringToUnsignedChars(DFA82_minS);
    static final char[] DFA82_max = DFA.unpackEncodedStringToUnsignedChars(DFA82_maxS);
    static final short[] DFA82_accept = DFA.unpackEncodedString(DFA82_acceptS);
    static final short[] DFA82_special = DFA.unpackEncodedString(DFA82_specialS);
    static final short[][] DFA82_transition;

    static {
        int numStates = DFA82_transitionS.length;
        DFA82_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA82_transition[i] = DFA.unpackEncodedString(DFA82_transitionS[i]);
        }
    }

    class DFA82 extends DFA {

        public DFA82(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 82;
            this.eot = DFA82_eot;
            this.eof = DFA82_eof;
            this.min = DFA82_min;
            this.max = DFA82_max;
            this.accept = DFA82_accept;
            this.special = DFA82_special;
            this.transition = DFA82_transition;
        }
        public String getDescription() {
            return "1672:5: ( blockStatement | directive | namespaceDirective[null] | constantVarStatement[null] | tryStatement | switchStatement | withStatement | returnStatement | breakStatement | continueStatement | forStatement | forInStatement | forEachInStatement | doWhileStatement | whileStatement | ifStatement | variableStatement[null] | throwStatement | labelledStatement | expression semic | emptyStatement )";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA82_1 = input.LA(1);

                         
                        int index82_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred180_ASCollector()) ) {s = 48;}

                        else if ( (synpred196_ASCollector()) ) {s = 49;}

                        else if ( (synpred198_ASCollector()) ) {s = 50;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA82_2 = input.LA(1);

                         
                        int index82_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred180_ASCollector()) ) {s = 48;}

                        else if ( (synpred182_ASCollector()) ) {s = 51;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA82_3 = input.LA(1);

                         
                        int index82_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred180_ASCollector()) ) {s = 48;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA82_4 = input.LA(1);

                         
                        int index82_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred181_ASCollector()) ) {s = 52;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA82_5 = input.LA(1);

                         
                        int index82_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred181_ASCollector()) ) {s = 52;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA82_6 = input.LA(1);

                         
                        int index82_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred181_ASCollector()) ) {s = 52;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA82_7 = input.LA(1);

                         
                        int index82_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred181_ASCollector()) ) {s = 52;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA82_8 = input.LA(1);

                         
                        int index82_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred181_ASCollector()) ) {s = 52;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA82_9 = input.LA(1);

                         
                        int index82_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred180_ASCollector()) ) {s = 48;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA82_10 = input.LA(1);

                         
                        int index82_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred183_ASCollector()) ) {s = 53;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_10);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA82_11 = input.LA(1);

                         
                        int index82_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred184_ASCollector()) ) {s = 54;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_11);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA82_12 = input.LA(1);

                         
                        int index82_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred185_ASCollector()) ) {s = 55;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_12);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA82_13 = input.LA(1);

                         
                        int index82_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred186_ASCollector()) ) {s = 56;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_13);
                        if ( s>=0 ) return s;
                        break;
                    case 13 : 
                        int LA82_14 = input.LA(1);

                         
                        int index82_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred187_ASCollector()) ) {s = 57;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_14);
                        if ( s>=0 ) return s;
                        break;
                    case 14 : 
                        int LA82_15 = input.LA(1);

                         
                        int index82_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred188_ASCollector()) ) {s = 58;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_15);
                        if ( s>=0 ) return s;
                        break;
                    case 15 : 
                        int LA82_16 = input.LA(1);

                         
                        int index82_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred189_ASCollector()) ) {s = 59;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_16);
                        if ( s>=0 ) return s;
                        break;
                    case 16 : 
                        int LA82_17 = input.LA(1);

                         
                        int index82_17 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred190_ASCollector()) ) {s = 60;}

                        else if ( (synpred191_ASCollector()) ) {s = 61;}

                        else if ( (synpred192_ASCollector()) ) {s = 62;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_17);
                        if ( s>=0 ) return s;
                        break;
                    case 17 : 
                        int LA82_18 = input.LA(1);

                         
                        int index82_18 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred193_ASCollector()) ) {s = 63;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_18);
                        if ( s>=0 ) return s;
                        break;
                    case 18 : 
                        int LA82_19 = input.LA(1);

                         
                        int index82_19 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred194_ASCollector()) ) {s = 64;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_19);
                        if ( s>=0 ) return s;
                        break;
                    case 19 : 
                        int LA82_20 = input.LA(1);

                         
                        int index82_20 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred195_ASCollector()) ) {s = 65;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_20);
                        if ( s>=0 ) return s;
                        break;
                    case 20 : 
                        int LA82_21 = input.LA(1);

                         
                        int index82_21 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred196_ASCollector()) ) {s = 49;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_21);
                        if ( s>=0 ) return s;
                        break;
                    case 21 : 
                        int LA82_22 = input.LA(1);

                         
                        int index82_22 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred197_ASCollector()) ) {s = 66;}

                        else if ( (synpred199_ASCollector()) ) {s = 23;}

                         
                        input.seek(index82_22);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 82, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA92_eotS =
        "\63\uffff";
    static final String DFA92_eofS =
        "\1\2\62\uffff";
    static final String DFA92_minS =
        "\1\4\1\0\1\uffff\2\0\56\uffff";
    static final String DFA92_maxS =
        "\1\u0092\1\0\1\uffff\2\0\56\uffff";
    static final String DFA92_acceptS =
        "\2\uffff\1\2\3\uffff\1\1\54\uffff";
    static final String DFA92_specialS =
        "\1\uffff\1\0\1\uffff\1\1\1\2\56\uffff}>";
    static final String[] DFA92_transitionS = {
            "\1\6\1\1\1\3\4\6\1\4\60\6\1\2\1\6\1\uffff\1\6\3\uffff\1\6\7"+
            "\uffff\3\6\2\uffff\2\6\6\uffff\2\6\26\uffff\2\6\16\uffff\2\6"+
            "\2\uffff\1\6\4\uffff\1\6\2\uffff\1\6\1\uffff\1\6\1\uffff\3\6",
            "\1\uffff",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA92_eot = DFA.unpackEncodedString(DFA92_eotS);
    static final short[] DFA92_eof = DFA.unpackEncodedString(DFA92_eofS);
    static final char[] DFA92_min = DFA.unpackEncodedStringToUnsignedChars(DFA92_minS);
    static final char[] DFA92_max = DFA.unpackEncodedStringToUnsignedChars(DFA92_maxS);
    static final short[] DFA92_accept = DFA.unpackEncodedString(DFA92_acceptS);
    static final short[] DFA92_special = DFA.unpackEncodedString(DFA92_specialS);
    static final short[][] DFA92_transition;

    static {
        int numStates = DFA92_transitionS.length;
        DFA92_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA92_transition[i] = DFA.unpackEncodedString(DFA92_transitionS[i]);
        }
    }

    class DFA92 extends DFA {

        public DFA92(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 92;
            this.eot = DFA92_eot;
            this.eof = DFA92_eof;
            this.min = DFA92_min;
            this.max = DFA92_max;
            this.accept = DFA92_accept;
            this.special = DFA92_special;
            this.transition = DFA92_transition;
        }
        public String getDescription() {
            return "()* loopback of 1886:23: ( statement )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA92_1 = input.LA(1);

                         
                        int index92_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred210_ASCollector()) ) {s = 6;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index92_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA92_3 = input.LA(1);

                         
                        int index92_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred210_ASCollector()) ) {s = 6;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index92_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA92_4 = input.LA(1);

                         
                        int index92_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred210_ASCollector()) ) {s = 6;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index92_4);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 92, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA120_eotS =
        "\36\uffff";
    static final String DFA120_eofS =
        "\36\uffff";
    static final String DFA120_minS =
        "\1\4\31\0\1\uffff\1\0\2\uffff";
    static final String DFA120_maxS =
        "\1\u0092\31\0\1\uffff\1\0\2\uffff";
    static final String DFA120_acceptS =
        "\32\uffff\1\2\2\uffff\1\1";
    static final String DFA120_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"+
        "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"+
        "\1\uffff\1\31\2\uffff}>";
    static final String[] DFA120_transitionS = {
            "\10\33\1\31\3\33\1\5\2\33\1\20\10\33\1\16\1\30\1\3\5\33\1\2"+
            "\1\33\1\1\1\33\1\16\1\4\1\33\1\31\2\33\1\31\2\33\4\16\1\33\4"+
            "\16\1\uffff\1\14\1\uffff\1\27\1\uffff\1\13\3\uffff\1\25\7\uffff"+
            "\2\32\1\21\2\uffff\2\32\6\uffff\2\32\26\uffff\1\17\1\26\16\uffff"+
            "\1\10\1\11\2\uffff\1\12\4\uffff\1\7\2\uffff\1\6\1\uffff\1\15"+
            "\1\uffff\1\22\1\23\1\24",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA120_eot = DFA.unpackEncodedString(DFA120_eotS);
    static final short[] DFA120_eof = DFA.unpackEncodedString(DFA120_eofS);
    static final char[] DFA120_min = DFA.unpackEncodedStringToUnsignedChars(DFA120_minS);
    static final char[] DFA120_max = DFA.unpackEncodedStringToUnsignedChars(DFA120_maxS);
    static final short[] DFA120_accept = DFA.unpackEncodedString(DFA120_acceptS);
    static final short[] DFA120_special = DFA.unpackEncodedString(DFA120_specialS);
    static final short[][] DFA120_transition;

    static {
        int numStates = DFA120_transitionS.length;
        DFA120_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA120_transition[i] = DFA.unpackEncodedString(DFA120_transitionS[i]);
        }
    }

    class DFA120 extends DFA {

        public DFA120(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 120;
            this.eot = DFA120_eot;
            this.eof = DFA120_eof;
            this.min = DFA120_min;
            this.max = DFA120_max;
            this.accept = DFA120_accept;
            this.special = DFA120_special;
            this.transition = DFA120_transition;
        }
        public String getDescription() {
            return "2155:1: assignmentExpression : ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpression | conditionalExpression );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA120_1 = input.LA(1);

                         
                        int index120_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA120_2 = input.LA(1);

                         
                        int index120_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA120_3 = input.LA(1);

                         
                        int index120_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA120_4 = input.LA(1);

                         
                        int index120_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA120_5 = input.LA(1);

                         
                        int index120_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA120_6 = input.LA(1);

                         
                        int index120_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA120_7 = input.LA(1);

                         
                        int index120_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA120_8 = input.LA(1);

                         
                        int index120_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA120_9 = input.LA(1);

                         
                        int index120_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA120_10 = input.LA(1);

                         
                        int index120_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_10);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA120_11 = input.LA(1);

                         
                        int index120_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_11);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA120_12 = input.LA(1);

                         
                        int index120_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_12);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA120_13 = input.LA(1);

                         
                        int index120_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_13);
                        if ( s>=0 ) return s;
                        break;
                    case 13 : 
                        int LA120_14 = input.LA(1);

                         
                        int index120_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_14);
                        if ( s>=0 ) return s;
                        break;
                    case 14 : 
                        int LA120_15 = input.LA(1);

                         
                        int index120_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_15);
                        if ( s>=0 ) return s;
                        break;
                    case 15 : 
                        int LA120_16 = input.LA(1);

                         
                        int index120_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_16);
                        if ( s>=0 ) return s;
                        break;
                    case 16 : 
                        int LA120_17 = input.LA(1);

                         
                        int index120_17 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_17);
                        if ( s>=0 ) return s;
                        break;
                    case 17 : 
                        int LA120_18 = input.LA(1);

                         
                        int index120_18 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_18);
                        if ( s>=0 ) return s;
                        break;
                    case 18 : 
                        int LA120_19 = input.LA(1);

                         
                        int index120_19 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_19);
                        if ( s>=0 ) return s;
                        break;
                    case 19 : 
                        int LA120_20 = input.LA(1);

                         
                        int index120_20 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_20);
                        if ( s>=0 ) return s;
                        break;
                    case 20 : 
                        int LA120_21 = input.LA(1);

                         
                        int index120_21 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_21);
                        if ( s>=0 ) return s;
                        break;
                    case 21 : 
                        int LA120_22 = input.LA(1);

                         
                        int index120_22 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_22);
                        if ( s>=0 ) return s;
                        break;
                    case 22 : 
                        int LA120_23 = input.LA(1);

                         
                        int index120_23 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_23);
                        if ( s>=0 ) return s;
                        break;
                    case 23 : 
                        int LA120_24 = input.LA(1);

                         
                        int index120_24 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_24);
                        if ( s>=0 ) return s;
                        break;
                    case 24 : 
                        int LA120_25 = input.LA(1);

                         
                        int index120_25 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_25);
                        if ( s>=0 ) return s;
                        break;
                    case 25 : 
                        int LA120_27 = input.LA(1);

                         
                        int index120_27 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred239_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index120_27);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 120, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA121_eotS =
        "\36\uffff";
    static final String DFA121_eofS =
        "\36\uffff";
    static final String DFA121_minS =
        "\1\4\31\0\1\uffff\1\0\2\uffff";
    static final String DFA121_maxS =
        "\1\u0092\31\0\1\uffff\1\0\2\uffff";
    static final String DFA121_acceptS =
        "\32\uffff\1\2\2\uffff\1\1";
    static final String DFA121_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1"+
        "\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30"+
        "\1\uffff\1\31\2\uffff}>";
    static final String[] DFA121_transitionS = {
            "\10\33\1\31\3\33\1\5\2\33\1\20\10\33\1\16\1\30\1\3\5\33\1\2"+
            "\1\33\1\1\1\33\1\16\1\4\1\33\1\31\2\33\1\31\2\33\4\16\1\33\4"+
            "\16\1\uffff\1\14\1\uffff\1\27\1\uffff\1\13\3\uffff\1\25\7\uffff"+
            "\2\32\1\21\2\uffff\2\32\6\uffff\2\32\26\uffff\1\17\1\26\16\uffff"+
            "\1\10\1\11\2\uffff\1\12\4\uffff\1\7\2\uffff\1\6\1\uffff\1\15"+
            "\1\uffff\1\22\1\23\1\24",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA121_eot = DFA.unpackEncodedString(DFA121_eotS);
    static final short[] DFA121_eof = DFA.unpackEncodedString(DFA121_eofS);
    static final char[] DFA121_min = DFA.unpackEncodedStringToUnsignedChars(DFA121_minS);
    static final char[] DFA121_max = DFA.unpackEncodedStringToUnsignedChars(DFA121_maxS);
    static final short[] DFA121_accept = DFA.unpackEncodedString(DFA121_acceptS);
    static final short[] DFA121_special = DFA.unpackEncodedString(DFA121_specialS);
    static final short[][] DFA121_transition;

    static {
        int numStates = DFA121_transitionS.length;
        DFA121_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA121_transition[i] = DFA.unpackEncodedString(DFA121_transitionS[i]);
        }
    }

    class DFA121 extends DFA {

        public DFA121(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 121;
            this.eot = DFA121_eot;
            this.eof = DFA121_eof;
            this.min = DFA121_min;
            this.max = DFA121_max;
            this.accept = DFA121_accept;
            this.special = DFA121_special;
            this.transition = DFA121_transition;
        }
        public String getDescription() {
            return "2162:1: assignmentExpressionNoIn : ( ( leftHandSideExpression assignmentOperator )=> leftHandSideExpression assignmentOperator assignmentExpressionNoIn | conditionalExpressionNoIn );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA121_1 = input.LA(1);

                         
                        int index121_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA121_2 = input.LA(1);

                         
                        int index121_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA121_3 = input.LA(1);

                         
                        int index121_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA121_4 = input.LA(1);

                         
                        int index121_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA121_5 = input.LA(1);

                         
                        int index121_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA121_6 = input.LA(1);

                         
                        int index121_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA121_7 = input.LA(1);

                         
                        int index121_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA121_8 = input.LA(1);

                         
                        int index121_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA121_9 = input.LA(1);

                         
                        int index121_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA121_10 = input.LA(1);

                         
                        int index121_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_10);
                        if ( s>=0 ) return s;
                        break;
                    case 10 : 
                        int LA121_11 = input.LA(1);

                         
                        int index121_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_11);
                        if ( s>=0 ) return s;
                        break;
                    case 11 : 
                        int LA121_12 = input.LA(1);

                         
                        int index121_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_12);
                        if ( s>=0 ) return s;
                        break;
                    case 12 : 
                        int LA121_13 = input.LA(1);

                         
                        int index121_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_13);
                        if ( s>=0 ) return s;
                        break;
                    case 13 : 
                        int LA121_14 = input.LA(1);

                         
                        int index121_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_14);
                        if ( s>=0 ) return s;
                        break;
                    case 14 : 
                        int LA121_15 = input.LA(1);

                         
                        int index121_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_15);
                        if ( s>=0 ) return s;
                        break;
                    case 15 : 
                        int LA121_16 = input.LA(1);

                         
                        int index121_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_16);
                        if ( s>=0 ) return s;
                        break;
                    case 16 : 
                        int LA121_17 = input.LA(1);

                         
                        int index121_17 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_17);
                        if ( s>=0 ) return s;
                        break;
                    case 17 : 
                        int LA121_18 = input.LA(1);

                         
                        int index121_18 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_18);
                        if ( s>=0 ) return s;
                        break;
                    case 18 : 
                        int LA121_19 = input.LA(1);

                         
                        int index121_19 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_19);
                        if ( s>=0 ) return s;
                        break;
                    case 19 : 
                        int LA121_20 = input.LA(1);

                         
                        int index121_20 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_20);
                        if ( s>=0 ) return s;
                        break;
                    case 20 : 
                        int LA121_21 = input.LA(1);

                         
                        int index121_21 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_21);
                        if ( s>=0 ) return s;
                        break;
                    case 21 : 
                        int LA121_22 = input.LA(1);

                         
                        int index121_22 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_22);
                        if ( s>=0 ) return s;
                        break;
                    case 22 : 
                        int LA121_23 = input.LA(1);

                         
                        int index121_23 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_23);
                        if ( s>=0 ) return s;
                        break;
                    case 23 : 
                        int LA121_24 = input.LA(1);

                         
                        int index121_24 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_24);
                        if ( s>=0 ) return s;
                        break;
                    case 24 : 
                        int LA121_25 = input.LA(1);

                         
                        int index121_25 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_25);
                        if ( s>=0 ) return s;
                        break;
                    case 25 : 
                        int LA121_27 = input.LA(1);

                         
                        int index121_27 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred240_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 26;}

                         
                        input.seek(index121_27);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 121, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA122_eotS =
        "\21\uffff";
    static final String DFA122_eofS =
        "\21\uffff";
    static final String DFA122_minS =
        "\1\104\7\uffff\1\104\5\uffff\1\104\2\uffff";
    static final String DFA122_maxS =
        "\1\152\7\uffff\1\104\5\uffff\1\136\2\uffff";
    static final String DFA122_acceptS =
        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\uffff\1\12\1\13\1\14\1\15"+
        "\1\16\1\uffff\1\10\1\11";
    static final String DFA122_specialS =
        "\16\uffff\1\0\2\uffff}>";
    static final String[] DFA122_transitionS = {
            "\1\10\10\uffff\1\2\20\uffff\1\1\1\3\1\4\1\5\1\6\1\7\2\uffff"+
            "\1\15\1\14\1\11\1\12\1\13",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\16",
            "",
            "",
            "",
            "",
            "",
            "\1\20\31\uffff\1\17",
            "",
            ""
    };

    static final short[] DFA122_eot = DFA.unpackEncodedString(DFA122_eotS);
    static final short[] DFA122_eof = DFA.unpackEncodedString(DFA122_eofS);
    static final char[] DFA122_min = DFA.unpackEncodedStringToUnsignedChars(DFA122_minS);
    static final char[] DFA122_max = DFA.unpackEncodedStringToUnsignedChars(DFA122_maxS);
    static final short[] DFA122_accept = DFA.unpackEncodedString(DFA122_acceptS);
    static final short[] DFA122_special = DFA.unpackEncodedString(DFA122_specialS);
    static final short[][] DFA122_transition;

    static {
        int numStates = DFA122_transitionS.length;
        DFA122_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA122_transition[i] = DFA.unpackEncodedString(DFA122_transitionS[i]);
        }
    }

    class DFA122 extends DFA {

        public DFA122(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 122;
            this.eot = DFA122_eot;
            this.eof = DFA122_eof;
            this.min = DFA122_min;
            this.max = DFA122_max;
            this.accept = DFA122_accept;
            this.special = DFA122_special;
            this.transition = DFA122_transition;
        }
        public String getDescription() {
            return "2173:1: assignmentOperator_int : ( ASSIGN | s= STAR a= ASSIGN | DIV_ASSIGN | MOD_ASSIGN | ADD_ASSIGN | SUB_ASSIGN | SHL_ASSIGN | ( '>' '>' '=' )=>t1= '>' t2= '>' t3= '=' {...}? | ( '>' '>' '>' '=' )=>t1= '>' t2= '>' t3= '>' t4= '=' {...}? | AND_ASSIGN | XOR_ASSIGN | OR_ASSIGN | LOR_ASSIGN | LAND_ASSIGN );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA122_14 = input.LA(1);

                         
                        int index122_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (LA122_14==ASSIGN) && (synpred248_ASCollector())) {s = 15;}

                        else if ( (LA122_14==GT) && (synpred249_ASCollector())) {s = 16;}

                         
                        input.seek(index122_14);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 122, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA139_eotS =
        "\131\uffff";
    static final String DFA139_eofS =
        "\1\1\130\uffff";
    static final String DFA139_minS =
        "\1\4\65\uffff\1\0\11\uffff\1\0\2\uffff\1\0\6\uffff\1\0\11\uffff"+
        "\1\0\4\uffff";
    static final String DFA139_maxS =
        "\1\u0092\65\uffff\1\0\11\uffff\1\0\2\uffff\1\0\6\uffff\1\0\11\uffff"+
        "\1\0\4\uffff";
    static final String DFA139_acceptS =
        "\1\uffff\1\2\126\uffff\1\1";
    static final String DFA139_specialS =
        "\66\uffff\1\0\11\uffff\1\1\2\uffff\1\2\6\uffff\1\3\11\uffff\1\4"+
        "\4\uffff}>";
    static final String[] DFA139_transitionS = {
            "\1\103\22\1\1\100\1\103\2\1\1\103\47\1\1\66\1\112\1\124\1\uffff"+
            "\14\1\2\uffff\17\1\2\uffff\5\1\1\uffff\1\1\2\uffff\3\1\16\uffff"+
            "\2\1\2\uffff\1\1\4\uffff\1\1\2\uffff\1\1\1\uffff\1\1\1\uffff"+
            "\3\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA139_eot = DFA.unpackEncodedString(DFA139_eotS);
    static final short[] DFA139_eof = DFA.unpackEncodedString(DFA139_eofS);
    static final char[] DFA139_min = DFA.unpackEncodedStringToUnsignedChars(DFA139_minS);
    static final char[] DFA139_max = DFA.unpackEncodedStringToUnsignedChars(DFA139_maxS);
    static final short[] DFA139_accept = DFA.unpackEncodedString(DFA139_acceptS);
    static final short[] DFA139_special = DFA.unpackEncodedString(DFA139_specialS);
    static final short[][] DFA139_transition;

    static {
        int numStates = DFA139_transitionS.length;
        DFA139_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA139_transition[i] = DFA.unpackEncodedString(DFA139_transitionS[i]);
        }
    }

    class DFA139 extends DFA {

        public DFA139(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 139;
            this.eot = DFA139_eot;
            this.eof = DFA139_eof;
            this.min = DFA139_min;
            this.max = DFA139_max;
            this.accept = DFA139_accept;
            this.special = DFA139_special;
            this.transition = DFA139_transition;
        }
        public String getDescription() {
            return "()* loopback of 2281:6: ( (g= GT (assign= ASSIGN )? | eq= ( IN | LT | LTE | INSTANCEOF | IS | AS ) ) shiftExpression )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA139_54 = input.LA(1);

                         
                        int index139_54 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred281_ASCollector()) ) {s = 88;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index139_54);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA139_64 = input.LA(1);

                         
                        int index139_64 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred281_ASCollector()) ) {s = 88;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index139_64);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA139_67 = input.LA(1);

                         
                        int index139_67 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred281_ASCollector()) ) {s = 88;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index139_67);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA139_74 = input.LA(1);

                         
                        int index139_74 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred281_ASCollector()) ) {s = 88;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index139_74);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA139_84 = input.LA(1);

                         
                        int index139_84 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred281_ASCollector()) ) {s = 88;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index139_84);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 139, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA143_eotS =
        "\41\uffff";
    static final String DFA143_eofS =
        "\41\uffff";
    static final String DFA143_minS =
        "\1\104\1\uffff\1\104\1\4\35\uffff";
    static final String DFA143_maxS =
        "\1\122\1\uffff\1\104\1\u0092\35\uffff";
    static final String DFA143_acceptS =
        "\1\uffff\1\1\2\uffff\1\3\34\2";
    static final String DFA143_specialS =
        "\3\uffff\1\0\35\uffff}>";
    static final String[] DFA143_transitionS = {
            "\1\2\15\uffff\1\1",
            "",
            "\1\3",
            "\10\37\1\35\3\37\1\11\2\37\1\24\10\37\1\22\1\34\1\7\5\37\1"+
            "\6\1\37\1\5\1\37\1\22\1\10\1\37\1\35\2\37\1\35\2\37\4\22\1\37"+
            "\4\22\1\uffff\1\20\1\uffff\1\33\1\uffff\1\17\3\uffff\1\31\1"+
            "\4\6\uffff\2\40\1\25\2\uffff\2\40\6\uffff\2\36\26\uffff\1\23"+
            "\1\32\16\uffff\1\14\1\15\2\uffff\1\16\4\uffff\1\13\2\uffff\1"+
            "\12\1\uffff\1\21\1\uffff\1\26\1\27\1\30",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA143_eot = DFA.unpackEncodedString(DFA143_eotS);
    static final short[] DFA143_eof = DFA.unpackEncodedString(DFA143_eofS);
    static final char[] DFA143_min = DFA.unpackEncodedStringToUnsignedChars(DFA143_minS);
    static final char[] DFA143_max = DFA.unpackEncodedStringToUnsignedChars(DFA143_maxS);
    static final short[] DFA143_accept = DFA.unpackEncodedString(DFA143_acceptS);
    static final short[] DFA143_special = DFA.unpackEncodedString(DFA143_specialS);
    static final short[][] DFA143_transition;

    static {
        int numStates = DFA143_transitionS.length;
        DFA143_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA143_transition[i] = DFA.unpackEncodedString(DFA143_transitionS[i]);
        }
    }

    class DFA143 extends DFA {

        public DFA143(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 143;
            this.eot = DFA143_eot;
            this.eof = DFA143_eof;
            this.min = DFA143_min;
            this.max = DFA143_max;
            this.accept = DFA143_accept;
            this.special = DFA143_special;
            this.transition = DFA143_transition;
        }
        public String getDescription() {
            return "2314:7: (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?)";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA143_3 = input.LA(1);

                         
                        int index143_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (LA143_3==GT) && (synpred291_ASCollector())) {s = 4;}

                        else if ( (LA143_3==THIS) && (synpred290_ASCollector())) {s = 5;}

                        else if ( (LA143_3==SUPER) && (synpred290_ASCollector())) {s = 6;}

                        else if ( (LA143_3==NULL) && (synpred290_ASCollector())) {s = 7;}

                        else if ( (LA143_3==TRUE) && (synpred290_ASCollector())) {s = 8;}

                        else if ( (LA143_3==FALSE) && (synpred290_ASCollector())) {s = 9;}

                        else if ( (LA143_3==DEC_NUMBER_LITERAL) && (synpred290_ASCollector())) {s = 10;}

                        else if ( (LA143_3==HEX_NUMBER_LITERAL) && (synpred290_ASCollector())) {s = 11;}

                        else if ( (LA143_3==SINGLE_QUOTE_LITERAL) && (synpred290_ASCollector())) {s = 12;}

                        else if ( (LA143_3==DOUBLE_QUOTE_LITERAL) && (synpred290_ASCollector())) {s = 13;}

                        else if ( (LA143_3==REGULAR_EXPR_LITERAL) && (synpred290_ASCollector())) {s = 14;}

                        else if ( (LA143_3==LBRACK) && (synpred290_ASCollector())) {s = 15;}

                        else if ( (LA143_3==LCURLY) && (synpred290_ASCollector())) {s = 16;}

                        else if ( (LA143_3==IDENTIFIER) && (synpred290_ASCollector())) {s = 17;}

                        else if ( (LA143_3==NATIVE||LA143_3==TO||(LA143_3>=EACH && LA143_3<=NAMESPACE)||(LA143_3>=DYNAMIC && LA143_3<=STATIC)) && (synpred290_ASCollector())) {s = 18;}

                        else if ( (LA143_3==XML_AT) && (synpred290_ASCollector())) {s = 19;}

                        else if ( (LA143_3==FUNCTION) && (synpred290_ASCollector())) {s = 20;}

                        else if ( (LA143_3==STAR) && (synpred290_ASCollector())) {s = 21;}

                        else if ( (LA143_3==XML_COMMENT) && (synpred290_ASCollector())) {s = 22;}

                        else if ( (LA143_3==XML_CDATA) && (synpred290_ASCollector())) {s = 23;}

                        else if ( (LA143_3==XML_PI) && (synpred290_ASCollector())) {s = 24;}

                        else if ( (LA143_3==LT) && (synpred290_ASCollector())) {s = 25;}

                        else if ( (LA143_3==XML_LS_STD) && (synpred290_ASCollector())) {s = 26;}

                        else if ( (LA143_3==LPAREN) && (synpred290_ASCollector())) {s = 27;}

                        else if ( (LA143_3==NEW) && (synpred290_ASCollector())) {s = 28;}

                        else if ( (LA143_3==DELETE||LA143_3==TYPEOF||LA143_3==VOID) && (synpred290_ASCollector())) {s = 29;}

                        else if ( ((LA143_3>=NOT && LA143_3<=INV)) && (synpred290_ASCollector())) {s = 30;}

                        else if ( ((LA143_3>=AS && LA143_3<=DEFAULT)||(LA143_3>=DO && LA143_3<=EXTENDS)||(LA143_3>=FINALLY && LA143_3<=FOR)||(LA143_3>=IF && LA143_3<=IS)||(LA143_3>=PACKAGE && LA143_3<=RETURN)||LA143_3==SWITCH||LA143_3==THROW||LA143_3==TRY||(LA143_3>=USE && LA143_3<=VAR)||(LA143_3>=WHILE && LA143_3<=WITH)||LA143_3==INCLUDE) && (synpred290_ASCollector())) {s = 31;}

                        else if ( ((LA143_3>=PLUS && LA143_3<=SUB)||(LA143_3>=INC && LA143_3<=DEC)) && (synpred290_ASCollector())) {s = 32;}

                         
                        input.seek(index143_3);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 143, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA147_eotS =
        "\36\uffff";
    static final String DFA147_eofS =
        "\36\uffff";
    static final String DFA147_minS =
        "\1\4\30\uffff\2\0\3\uffff";
    static final String DFA147_maxS =
        "\1\u0092\30\uffff\2\0\3\uffff";
    static final String DFA147_acceptS =
        "\1\uffff\1\1\32\uffff\1\3\1\2";
    static final String DFA147_specialS =
        "\31\uffff\1\0\1\1\3\uffff}>";
    static final String[] DFA147_transitionS = {
            "\10\1\1\31\36\1\1\31\2\1\1\31\13\1\1\uffff\1\1\1\uffff\1\1"+
            "\1\uffff\1\1\3\uffff\1\1\7\uffff\2\34\1\1\2\uffff\2\34\6\uffff"+
            "\2\32\26\uffff\2\1\16\uffff\2\1\2\uffff\1\1\4\uffff\1\1\2\uffff"+
            "\1\1\1\uffff\1\1\1\uffff\3\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA147_eot = DFA.unpackEncodedString(DFA147_eotS);
    static final short[] DFA147_eof = DFA.unpackEncodedString(DFA147_eofS);
    static final char[] DFA147_min = DFA.unpackEncodedStringToUnsignedChars(DFA147_minS);
    static final char[] DFA147_max = DFA.unpackEncodedStringToUnsignedChars(DFA147_maxS);
    static final short[] DFA147_accept = DFA.unpackEncodedString(DFA147_acceptS);
    static final short[] DFA147_special = DFA.unpackEncodedString(DFA147_specialS);
    static final short[][] DFA147_transition;

    static {
        int numStates = DFA147_transitionS.length;
        DFA147_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA147_transition[i] = DFA.unpackEncodedString(DFA147_transitionS[i]);
        }
    }

    class DFA147 extends DFA {

        public DFA147(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 147;
            this.eot = DFA147_eot;
            this.eof = DFA147_eof;
            this.min = DFA147_min;
            this.max = DFA147_max;
            this.accept = DFA147_accept;
            this.special = DFA147_special;
            this.transition = DFA147_transition;
        }
        public String getDescription() {
            return "2352:1: unaryExpression : ( postfixExpression | op= ( NOT | INV ) unaryExpression | unaryOp postfixExpression );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA147_25 = input.LA(1);

                         
                        int index147_25 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred298_ASCollector()) ) {s = 1;}

                        else if ( (true) ) {s = 28;}

                         
                        input.seek(index147_25);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA147_26 = input.LA(1);

                         
                        int index147_26 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred300_ASCollector()) ) {s = 29;}

                        else if ( (true) ) {s = 28;}

                         
                        input.seek(index147_26);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 147, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA151_eotS =
        "\15\uffff";
    static final String DFA151_eofS =
        "\1\1\14\uffff";
    static final String DFA151_minS =
        "\1\4\1\uffff\5\0\6\uffff";
    static final String DFA151_maxS =
        "\1\u0092\1\uffff\5\0\6\uffff";
    static final String DFA151_acceptS =
        "\1\uffff\1\7\5\uffff\1\2\1\1\1\3\1\4\1\5\1\6";
    static final String DFA151_specialS =
        "\2\uffff\1\3\1\0\1\4\1\2\1\1\6\uffff}>";
    static final String[] DFA151_transitionS = {
            "\71\1\1\3\1\1\1\2\1\1\1\5\4\1\1\uffff\14\1\2\uffff\17\1\2\uffff"+
            "\5\1\1\uffff\1\4\2\uffff\1\6\2\1\16\uffff\2\1\2\uffff\1\1\4"+
            "\uffff\1\1\2\uffff\1\1\1\uffff\1\1\1\uffff\3\1",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA151_eot = DFA.unpackEncodedString(DFA151_eotS);
    static final short[] DFA151_eof = DFA.unpackEncodedString(DFA151_eofS);
    static final char[] DFA151_min = DFA.unpackEncodedStringToUnsignedChars(DFA151_minS);
    static final char[] DFA151_max = DFA.unpackEncodedStringToUnsignedChars(DFA151_maxS);
    static final short[] DFA151_accept = DFA.unpackEncodedString(DFA151_acceptS);
    static final short[] DFA151_special = DFA.unpackEncodedString(DFA151_specialS);
    static final short[][] DFA151_transition;

    static {
        int numStates = DFA151_transitionS.length;
        DFA151_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA151_transition[i] = DFA.unpackEncodedString(DFA151_transitionS[i]);
        }
    }

    class DFA151 extends DFA {

        public DFA151(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 151;
            this.eot = DFA151_eot;
            this.eof = DFA151_eof;
            this.min = DFA151_min;
            this.max = DFA151_max;
            this.accept = DFA151_accept;
            this.special = DFA151_special;
            this.transition = DFA151_transition;
        }
        public String getDescription() {
            return "()* loopback of 2388:5: ( arguments | L= LBRACK expression R= RBRACK | XML_ELLIPSIS eitherIdentifier | DOT ( eitherIdentifier | parExpression ) | typePostfixSyntax | XML_NS_OP expression )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA151_3 = input.LA(1);

                         
                        int index151_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred313_ASCollector()) ) {s = 8;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index151_3);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA151_6 = input.LA(1);

                         
                        int index151_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred319_ASCollector()) ) {s = 12;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index151_6);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA151_5 = input.LA(1);

                         
                        int index151_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred317_ASCollector()) ) {s = 10;}

                        else if ( (synpred318_ASCollector()) ) {s = 11;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index151_5);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA151_2 = input.LA(1);

                         
                        int index151_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred314_ASCollector()) ) {s = 7;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index151_2);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA151_4 = input.LA(1);

                         
                        int index151_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred315_ASCollector()) ) {s = 9;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index151_4);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 151, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA161_eotS =
        "\34\uffff";
    static final String DFA161_eofS =
        "\34\uffff";
    static final String DFA161_minS =
        "\1\4\5\0\7\uffff\2\0\6\uffff\1\0\6\uffff";
    static final String DFA161_maxS =
        "\1\u0092\5\0\7\uffff\2\0\6\uffff\1\0\6\uffff";
    static final String DFA161_acceptS =
        "\6\uffff\1\3\4\uffff\1\4\1\5\2\uffff\1\7\7\uffff\1\10\1\1\1\2\1"+
        "\6\1\11";
    static final String DFA161_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\7\uffff\1\5\1\6\6\uffff\1\7\6\uffff}>";
    static final String[] DFA161_transitionS = {
            "\14\17\1\5\13\17\1\16\1\17\1\3\5\17\1\2\1\17\1\1\1\17\1\16"+
            "\1\4\7\17\4\16\1\17\4\16\1\uffff\1\14\1\uffff\1\27\1\uffff\1"+
            "\13\3\uffff\1\25\11\uffff\1\17\42\uffff\2\17\16\uffff\2\6\2"+
            "\uffff\1\6\4\uffff\1\6\2\uffff\1\6\1\uffff\1\15\1\uffff\3\17",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA161_eot = DFA.unpackEncodedString(DFA161_eotS);
    static final short[] DFA161_eof = DFA.unpackEncodedString(DFA161_eofS);
    static final char[] DFA161_min = DFA.unpackEncodedStringToUnsignedChars(DFA161_minS);
    static final char[] DFA161_max = DFA.unpackEncodedStringToUnsignedChars(DFA161_maxS);
    static final short[] DFA161_accept = DFA.unpackEncodedString(DFA161_acceptS);
    static final short[] DFA161_special = DFA.unpackEncodedString(DFA161_specialS);
    static final short[][] DFA161_transition;

    static {
        int numStates = DFA161_transitionS.length;
        DFA161_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA161_transition[i] = DFA.unpackEncodedString(DFA161_transitionS[i]);
        }
    }

    class DFA161 extends DFA {

        public DFA161(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 161;
            this.eot = DFA161_eot;
            this.eof = DFA161_eof;
            this.min = DFA161_min;
            this.max = DFA161_max;
            this.accept = DFA161_accept;
            this.special = DFA161_special;
            this.transition = DFA161_transition;
        }
        public String getDescription() {
            return "2516:1: primaryExpressionHelper : (T= THIS | S= SUPER | literal | arrayLiteral | objectLiteral | ( identifierLiteral XML_NS_OP )? identifierLiteral | xmlPrimaryExpression | parExpression | LT type GT ( arrayLiteral )? );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA161_1 = input.LA(1);

                         
                        int index161_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred383_ASCollector()) ) {s = 24;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA161_2 = input.LA(1);

                         
                        int index161_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred384_ASCollector()) ) {s = 25;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA161_3 = input.LA(1);

                         
                        int index161_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred385_ASCollector()) ) {s = 6;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA161_4 = input.LA(1);

                         
                        int index161_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred385_ASCollector()) ) {s = 6;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA161_5 = input.LA(1);

                         
                        int index161_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred385_ASCollector()) ) {s = 6;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA161_13 = input.LA(1);

                         
                        int index161_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred389_ASCollector()) ) {s = 26;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_13);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA161_14 = input.LA(1);

                         
                        int index161_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred389_ASCollector()) ) {s = 26;}

                        else if ( (synpred390_ASCollector()) ) {s = 15;}

                         
                        input.seek(index161_14);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA161_21 = input.LA(1);

                         
                        int index161_21 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred390_ASCollector()) ) {s = 15;}

                        else if ( (true) ) {s = 27;}

                         
                        input.seek(index161_21);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 161, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA160_eotS =
        "\131\uffff";
    static final String DFA160_eofS =
        "\1\2\130\uffff";
    static final String DFA160_minS =
        "\1\4\1\0\127\uffff";
    static final String DFA160_maxS =
        "\1\u0092\1\0\127\uffff";
    static final String DFA160_acceptS =
        "\2\uffff\1\2\125\uffff\1\1";
    static final String DFA160_specialS =
        "\1\uffff\1\0\127\uffff}>";
    static final String[] DFA160_transitionS = {
            "\73\2\1\1\6\2\1\uffff\14\2\2\uffff\17\2\2\uffff\5\2\1\uffff"+
            "\1\2\2\uffff\3\2\16\uffff\2\2\2\uffff\1\2\4\uffff\1\2\2\uffff"+
            "\1\2\1\uffff\1\2\1\uffff\3\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA160_eot = DFA.unpackEncodedString(DFA160_eotS);
    static final short[] DFA160_eof = DFA.unpackEncodedString(DFA160_eofS);
    static final char[] DFA160_min = DFA.unpackEncodedStringToUnsignedChars(DFA160_minS);
    static final char[] DFA160_max = DFA.unpackEncodedStringToUnsignedChars(DFA160_maxS);
    static final short[] DFA160_accept = DFA.unpackEncodedString(DFA160_acceptS);
    static final short[] DFA160_special = DFA.unpackEncodedString(DFA160_specialS);
    static final short[][] DFA160_transition;

    static {
        int numStates = DFA160_transitionS.length;
        DFA160_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA160_transition[i] = DFA.unpackEncodedString(DFA160_transitionS[i]);
        }
    }

    class DFA160 extends DFA {

        public DFA160(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 160;
            this.eot = DFA160_eot;
            this.eof = DFA160_eof;
            this.min = DFA160_min;
            this.max = DFA160_max;
            this.accept = DFA160_accept;
            this.special = DFA160_special;
            this.transition = DFA160_transition;
        }
        public String getDescription() {
            return "2525:20: ( arrayLiteral )?";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA160_1 = input.LA(1);

                         
                        int index160_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred392_ASCollector()) ) {s = 88;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index160_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 160, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA186_eotS =
        "\41\uffff";
    static final String DFA186_eofS =
        "\41\uffff";
    static final String DFA186_minS =
        "\1\104\1\uffff\1\104\1\4\35\uffff";
    static final String DFA186_maxS =
        "\1\122\1\uffff\1\104\1\u0092\35\uffff";
    static final String DFA186_acceptS =
        "\1\uffff\1\1\2\uffff\1\3\34\2";
    static final String DFA186_specialS =
        "\3\uffff\1\0\35\uffff}>";
    static final String[] DFA186_transitionS = {
            "\1\2\15\uffff\1\1",
            "",
            "\1\3",
            "\10\37\1\35\3\37\1\11\2\37\1\24\10\37\1\22\1\34\1\7\5\37\1"+
            "\6\1\37\1\5\1\37\1\22\1\10\1\37\1\35\2\37\1\35\2\37\4\22\1\37"+
            "\4\22\1\uffff\1\20\1\uffff\1\33\1\uffff\1\17\3\uffff\1\31\1"+
            "\4\6\uffff\2\40\1\25\2\uffff\2\40\6\uffff\2\36\26\uffff\1\23"+
            "\1\32\16\uffff\1\14\1\15\2\uffff\1\16\4\uffff\1\13\2\uffff\1"+
            "\12\1\uffff\1\21\1\uffff\1\26\1\27\1\30",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA186_eot = DFA.unpackEncodedString(DFA186_eotS);
    static final short[] DFA186_eof = DFA.unpackEncodedString(DFA186_eofS);
    static final char[] DFA186_min = DFA.unpackEncodedStringToUnsignedChars(DFA186_minS);
    static final char[] DFA186_max = DFA.unpackEncodedStringToUnsignedChars(DFA186_maxS);
    static final short[] DFA186_accept = DFA.unpackEncodedString(DFA186_acceptS);
    static final short[] DFA186_special = DFA.unpackEncodedString(DFA186_specialS);
    static final short[][] DFA186_transition;

    static {
        int numStates = DFA186_transitionS.length;
        DFA186_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA186_transition[i] = DFA.unpackEncodedString(DFA186_transitionS[i]);
        }
    }

    class DFA186 extends DFA {

        public DFA186(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 186;
            this.eot = DFA186_eot;
            this.eof = DFA186_eof;
            this.min = DFA186_min;
            this.max = DFA186_max;
            this.accept = DFA186_accept;
            this.special = DFA186_special;
            this.transition = DFA186_transition;
        }
        public String getDescription() {
            return "2314:7: (t1= SHL | ( '>' '>' )=>t1= '>' t2= '>' {...}? | ( '>' '>' '>' )=>t1= '>' t2= '>' t3= '>' {...}?)";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA186_3 = input.LA(1);

                         
                        int index186_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (LA186_3==GT) && (synpred291_ASCollector())) {s = 4;}

                        else if ( (LA186_3==THIS) && (synpred290_ASCollector())) {s = 5;}

                        else if ( (LA186_3==SUPER) && (synpred290_ASCollector())) {s = 6;}

                        else if ( (LA186_3==NULL) && (synpred290_ASCollector())) {s = 7;}

                        else if ( (LA186_3==TRUE) && (synpred290_ASCollector())) {s = 8;}

                        else if ( (LA186_3==FALSE) && (synpred290_ASCollector())) {s = 9;}

                        else if ( (LA186_3==DEC_NUMBER_LITERAL) && (synpred290_ASCollector())) {s = 10;}

                        else if ( (LA186_3==HEX_NUMBER_LITERAL) && (synpred290_ASCollector())) {s = 11;}

                        else if ( (LA186_3==SINGLE_QUOTE_LITERAL) && (synpred290_ASCollector())) {s = 12;}

                        else if ( (LA186_3==DOUBLE_QUOTE_LITERAL) && (synpred290_ASCollector())) {s = 13;}

                        else if ( (LA186_3==REGULAR_EXPR_LITERAL) && (synpred290_ASCollector())) {s = 14;}

                        else if ( (LA186_3==LBRACK) && (synpred290_ASCollector())) {s = 15;}

                        else if ( (LA186_3==LCURLY) && (synpred290_ASCollector())) {s = 16;}

                        else if ( (LA186_3==IDENTIFIER) && (synpred290_ASCollector())) {s = 17;}

                        else if ( (LA186_3==NATIVE||LA186_3==TO||(LA186_3>=EACH && LA186_3<=NAMESPACE)||(LA186_3>=DYNAMIC && LA186_3<=STATIC)) && (synpred290_ASCollector())) {s = 18;}

                        else if ( (LA186_3==XML_AT) && (synpred290_ASCollector())) {s = 19;}

                        else if ( (LA186_3==FUNCTION) && (synpred290_ASCollector())) {s = 20;}

                        else if ( (LA186_3==STAR) && (synpred290_ASCollector())) {s = 21;}

                        else if ( (LA186_3==XML_COMMENT) && (synpred290_ASCollector())) {s = 22;}

                        else if ( (LA186_3==XML_CDATA) && (synpred290_ASCollector())) {s = 23;}

                        else if ( (LA186_3==XML_PI) && (synpred290_ASCollector())) {s = 24;}

                        else if ( (LA186_3==LT) && (synpred290_ASCollector())) {s = 25;}

                        else if ( (LA186_3==XML_LS_STD) && (synpred290_ASCollector())) {s = 26;}

                        else if ( (LA186_3==LPAREN) && (synpred290_ASCollector())) {s = 27;}

                        else if ( (LA186_3==NEW) && (synpred290_ASCollector())) {s = 28;}

                        else if ( (LA186_3==DELETE||LA186_3==TYPEOF||LA186_3==VOID) && (synpred290_ASCollector())) {s = 29;}

                        else if ( ((LA186_3>=NOT && LA186_3<=INV)) && (synpred290_ASCollector())) {s = 30;}

                        else if ( ((LA186_3>=AS && LA186_3<=DEFAULT)||(LA186_3>=DO && LA186_3<=EXTENDS)||(LA186_3>=FINALLY && LA186_3<=FOR)||(LA186_3>=IF && LA186_3<=IS)||(LA186_3>=PACKAGE && LA186_3<=RETURN)||LA186_3==SWITCH||LA186_3==THROW||LA186_3==TRY||(LA186_3>=USE && LA186_3<=VAR)||(LA186_3>=WHILE && LA186_3<=WITH)||LA186_3==INCLUDE) && (synpred290_ASCollector())) {s = 31;}

                        else if ( ((LA186_3>=PLUS && LA186_3<=SUB)||(LA186_3>=INC && LA186_3<=DEC)) && (synpred290_ASCollector())) {s = 32;}

                         
                        input.seek(index186_3);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 186, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

    public static final BitSet FOLLOW_TRUE_in_booleanLiteral3641 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FALSE_in_booleanLiteral3647 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEC_NUMBER_LITERAL_in_numericLiteral3679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_HEX_NUMBER_LITERAL_in_numericLiteral3685 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SINGLE_QUOTE_LITERAL_in_stringLiteral3718 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOUBLE_QUOTE_LITERAL_in_stringLiteral3724 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_REGULAR_EXPR_LITERAL_in_regularExpresionLiteral3748 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_identifierLiteral3780 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_notQuiteReservedWord_in_identifierLiteral3784 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_xmlNameLiteral3817 = new BitSet(new long[]{0x0000000000000002L,0x0000000020001002L});
    public static final BitSet FOLLOW_allKeywords_in_xmlNameLiteral3821 = new BitSet(new long[]{0x0000000000000002L,0x0000000020001002L});
    public static final BitSet FOLLOW_set_in_xmlNameLiteral3829 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_xmlNameLiteral3845 = new BitSet(new long[]{0x0000000000000002L,0x0000000020001002L});
    public static final BitSet FOLLOW_allKeywords_in_xmlNameLiteral3849 = new BitSet(new long[]{0x0000000000000002L,0x0000000020001002L});
    public static final BitSet FOLLOW_NULL_in_literal3902 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_booleanLiteral_in_literal3907 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numericLiteral_in_literal3911 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stringLiteral_in_literal3915 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_regularExpresionLiteral_in_literal3919 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlComment_in_xmlMarkup3955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlCDATA_in_xmlMarkup3959 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPI_in_xmlMarkup3963 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_COMMENT_in_xmlComment3998 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_CDATA_in_xmlCDATA4039 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_PI_in_xmlPI4081 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_xmlExprEval4118 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_xmlExprEval4121 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_RCURLY_in_xmlExprEval4125 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_allKeywords_in_xmlTextElement4142 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_xmlTextElement4155 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_TEXT_in_xmlText4878 = new BitSet(new long[]{0xF7FFFFFFFFFFFFF2L,0x00019FCFFFE7FFB7L,0x0000000000085203L});
    public static final BitSet FOLLOW_xmlTextElement_in_xmlText4883 = new BitSet(new long[]{0xF7FFFFFFFFFFFFF2L,0x00019FCFFFE7FFB7L,0x0000000000085203L});
    public static final BitSet FOLLOW_xmlPropertyIdentifier_in_xmlPrimaryExpression4907 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlInitialiser_in_xmlPrimaryExpression4917 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlListInitialiser_in_xmlPrimaryExpression4927 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlAttributeIdentifier_in_xmlPropertyIdentifier5020 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlQualifiedIdentifier_in_xmlPropertyIdentifier5032 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STAR_in_xmlPropertyIdentifier5046 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_AT_in_xmlAttributeIdentifier5110 = new BitSet(new long[]{0x83FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlQualifiedIdentifier_in_xmlAttributeIdentifier5135 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPropertySelector_in_xmlAttributeIdentifier5150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_indexSuffix_in_xmlAttributeIdentifier5165 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlNameLiteral_in_xmlPropertySelector5255 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STAR_in_xmlPropertySelector5268 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPropertySelector_in_xmlQualifiedIdentifier5288 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
    public static final BitSet FOLLOW_XML_NS_OP_in_xmlQualifiedIdentifier5293 = new BitSet(new long[]{0x83FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlPropertySelector_in_xmlQualifiedIdentifier5327 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_indexSuffix_in_xmlQualifiedIdentifier5339 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlMarkup_in_xmlInitialiser5364 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlElement_in_xmlInitialiser5374 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_xmlElement5411 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlTagName_in_xmlElement5414 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000200000000010L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlAttributes_in_xmlElement5416 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000010L});
    public static final BitSet FOLLOW_XML_TEND_in_xmlElement5436 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_xmlElement5478 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0001DFCFFFE7FFBFL,0x00000000000F5203L});
    public static final BitSet FOLLOW_xmlElementContent_in_xmlElement5480 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_XML_E_TEND_in_xmlElement5494 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlTagName_in_xmlElement5506 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_xmlElement5510 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlAttribute_in_xmlAttributes5546 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF2L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlExprEval_in_xmlTagName5576 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlNameLiteral_in_xmlTagName5586 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlTagName_in_xmlAttribute5608 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_xmlAttribute5613 = new BitSet(new long[]{0x0800000000000000L,0x0000000000000000L,0x0000000000000003L});
    public static final BitSet FOLLOW_xmlExprEval_in_xmlAttribute5631 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stringLiteral_in_xmlAttribute5643 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlElementContentHelper_in_xmlElementContent5674 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF2L,0x00019FCFFFE7FFBFL,0x00000000000F5203L});
    public static final BitSet FOLLOW_xmlExprEval_in_xmlElementContentHelper5692 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlMarkup_in_xmlElementContentHelper5701 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlElement_in_xmlElementContentHelper5710 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlText_in_xmlElementContentHelper5719 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_LS_STD_in_xmlListInitialiser5739 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x00059FCFFFE7FFBFL,0x00000000000F5203L});
    public static final BitSet FOLLOW_xmlElementContent_in_xmlListInitialiser5751 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L});
    public static final BitSet FOLLOW_XML_LS_END_in_xmlListInitialiser5762 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_semic5797 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EOF_in_semic5810 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RCURLY_in_semic5823 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_packageDeclaration_in_fileContents5843 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_packageElement_in_fileContents5846 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_EOF_in_fileContents5852 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration5869 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_packageDeclaration5872 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_packageDeclaration5885 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_packageElement_in_packageDeclaration5901 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_packageDeclaration5913 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_mxmlEmbedded5936 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_mxmlEmbedded5938 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_mxmlEmbedded_in_mxmlEmbedded5940 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_RCURLY_in_mxmlEmbedded5942 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_propertyDeclaration_in_mxmlEmbedded5955 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_functionDeclaration_in_mxmlEmbedded5959 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_mxmlEmbedded5964 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_directive_in_mxmlEmbedded5968 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_interfaceFunctionDeclaration_in_mxmlEmbedded5972 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_EOF_in_mxmlEmbedded5983 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_packageElement6005 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_packageElement6007 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_packageElement_in_packageElement6009 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_packageElement6012 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDecl_in_packageElement6029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_packageElement6033 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_packageElement6037 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFunctionDeclaration_in_packageElement6042 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_packageElement6047 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_packageElement6051 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPORT_in_importDeclaration6070 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_importDeclaration6075 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration6080 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_STAR_in_importDeclaration6085 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_importDeclaration6092 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalDirAndBindingDecls_in_classOrInterfaceDecl6120 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_memberModifiers_in_classOrInterfaceDecl6139 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_classOrInterfaceDecl6167 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_classOrInterfaceDecl6178 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_bindingDecl_in_directive6211 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_includeDirective_in_directive6215 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_useNamespaceDirective_in_directive6219 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_importDeclaration_in_directive6225 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_defaultXMLNamespaceDirective_in_directive6229 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_conditionalDirAndBindingDecls6252 = new BitSet(new long[]{0x8000000000000002L});
    public static final BitSet FOLLOW_bindingDecl_in_conditionalDirAndBindingDecls6268 = new BitSet(new long[]{0x8000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_xmlKeyword6291 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierLiteral_in_conditionalCompilerOption6306 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
    public static final BitSet FOLLOW_XML_NS_OP_in_conditionalCompilerOption6310 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_identifierLiteral_in_conditionalCompilerOption6313 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEFAULT_in_defaultXMLNamespaceDirective6336 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlKeyword_in_defaultXMLNamespaceDirective6343 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_NAMESPACE_in_defaultXMLNamespaceDirective6351 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_defaultXMLNamespaceDirective6357 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_defaultXMLNamespaceDirective6362 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_defaultXMLNamespaceDirective6369 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_bindingDecl6393 = new BitSet(new long[]{0x0000000000000000L,0x0001000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_XML_AT_in_bindingDecl6407 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_bindingDecl6413 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LPAREN_in_bindingDecl6429 = new BitSet(new long[]{0x43FFFFFFFFFFFFF0L,0x0001000000003800L,0x0000000000005203L});
    public static final BitSet FOLLOW_bindingDeclArg_in_bindingDecl6442 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_bindingDecl6458 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0001000000003800L,0x0000000000005203L});
    public static final BitSet FOLLOW_bindingDeclArg_in_bindingDecl6462 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_RPAREN_in_bindingDecl6494 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_RBRACK_in_bindingDecl6515 = new BitSet(new long[]{0x0400000000000002L});
    public static final BitSet FOLLOW_SEMI_in_bindingDecl6520 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INCLUDE_in_includeDirective6543 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000003L});
    public static final BitSet FOLLOW_stringLiteral_in_includeDirective6547 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_includeDirective6551 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_eitherIdentifier_in_bindingDeclArg6577 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_bindingDeclArg6582 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0001000000003800L,0x0000000000005203L});
    public static final BitSet FOLLOW_stringLiteral_in_bindingDeclArg6593 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_bindingDeclArg6597 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000001200L});
    public static final BitSet FOLLOW_numericLiteral_in_bindingDeclArg6606 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_eitherIdentifier_in_bindingDeclArg6611 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_bindingDeclArg6614 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0001000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_eitherIdentifier_in_bindingDeclArg6616 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_INTERFACE_in_interfaceDeclaration6644 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_interfaceDeclaration6663 = new BitSet(new long[]{0x0800000000008000L});
    public static final BitSet FOLLOW_EXTENDS_in_interfaceDeclaration6679 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_typeList_in_interfaceDeclaration6682 = new BitSet(new long[]{0x0800000000008000L});
    public static final BitSet FOLLOW_interfaceBody_in_interfaceDeclaration6695 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_interfaceBody6711 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_interfaceElement_in_interfaceBody6727 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_interfaceBody6745 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CLASS_in_classDeclaration6773 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_classDeclaration6785 = new BitSet(new long[]{0x0800000000208000L});
    public static final BitSet FOLLOW_EXTENDS_in_classDeclaration6798 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_classDeclaration6803 = new BitSet(new long[]{0x0800000000208000L});
    public static final BitSet FOLLOW_IMPLEMENTS_in_classDeclaration6826 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_typeList_in_classDeclaration6832 = new BitSet(new long[]{0x0800000000208000L});
    public static final BitSet FOLLOW_classBody_in_classDeclaration6851 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_classBody6880 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_classBodyElement_in_classBody6897 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_classBody6909 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_classBodyElement6939 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_classBodyElement6941 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_classBodyElement_in_classBodyElement6943 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_classBodyElement6946 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_classBodyElement6958 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_classBodyElement6962 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_classBodyElement6967 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_classBodyElement6971 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_interfaceElement6993 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_interfaceElement6995 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_interfaceElement_in_interfaceElement6997 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_interfaceElement7000 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_interfaceElement7016 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFunctionDeclaration_in_interfaceElement7020 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_interfaceElement7025 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_interfaceElement7029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalDirAndBindingDecls_in_interfaceFunctionDeclaration7080 = new BitSet(new long[]{0x03C0000714080000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_memberModifiers_in_interfaceFunctionDeclaration7114 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_FUNCTION_in_interfaceFunctionDeclaration7141 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_SET_in_interfaceFunctionDeclaration7164 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_GET_in_interfaceFunctionDeclaration7179 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_interfaceFunctionDeclaration7201 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_notQuiteReservedWord_in_interfaceFunctionDeclaration7215 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_formalParameterList_in_interfaceFunctionDeclaration7233 = new BitSet(new long[]{0x1400000000000000L,0x0000000020000002L});
    public static final BitSet FOLLOW_COLON_in_interfaceFunctionDeclaration7244 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_interfaceFunctionDeclaration7249 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_interfaceFunctionDeclaration7262 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalDirAndBindingDecls_in_propertyDeclaration7316 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_memberModifiers_in_propertyDeclaration7338 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableStatement_in_propertyDeclaration7361 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constantVarStatement_in_propertyDeclaration7377 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_namespaceDirective_in_propertyDeclaration7393 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalDirAndBindingDecls_in_functionDeclaration7456 = new BitSet(new long[]{0x03C0000714080000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_memberModifiers_in_functionDeclaration7494 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_FUNCTION_in_functionDeclaration7525 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_SET_in_functionDeclaration7553 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_GET_in_functionDeclaration7564 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_functionDeclaration7593 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_notQuiteReservedWord_in_functionDeclaration7607 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_formalParameterList_in_functionDeclaration7623 = new BitSet(new long[]{0x0800000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_functionDeclaration7634 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_functionDeclaration7639 = new BitSet(new long[]{0x0800000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_functionBody_in_functionDeclaration7653 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FUNCTION_in_functionExpression7686 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_functionExpression7692 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_formalParameterList_in_functionExpression7696 = new BitSet(new long[]{0x0800000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_functionExpression7702 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_functionExpression7705 = new BitSet(new long[]{0x0800000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_functionBody_in_functionExpression7710 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_formalParameterList7747 = new BitSet(new long[]{0x43FFFFFFFFFFFFF0L,0x0000080000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclaration_in_formalParameterList7764 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterList7800 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclaration_in_formalParameterList7834 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterList7871 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L});
    public static final BitSet FOLLOW_formalEllipsisParameter_in_formalParameterList7875 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_formalEllipsisParameter_in_formalParameterList7907 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_formalParameterList7932 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELLIPSIS_in_formalEllipsisParameter7978 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableIdentifierDecl_in_formalEllipsisParameter7982 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_functionBody8007 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_functionBody8024 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_functionDeclaration_in_functionBody8026 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_functionBody8040 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberModifier_in_memberModifiers8072 = new BitSet(new long[]{0x03C0000714000002L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_set_in_memberModifier8098 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_blockStatement_in_statement8253 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_statement8263 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_namespaceDirective_in_statement8273 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constantVarStatement_in_statement8285 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tryStatement_in_statement8297 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchStatement_in_statement8307 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_withStatement_in_statement8317 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_returnStatement_in_statement8329 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_breakStatement_in_statement8342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_continueStatement_in_statement8355 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forStatement_in_statement8366 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forInStatement_in_statement8376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forEachInStatement_in_statement8386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_doWhileStatement_in_statement8396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_whileStatement_in_statement8406 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStatement_in_statement8416 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableStatement_in_statement8428 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_throwStatement_in_statement8442 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_labelledStatement_in_statement8453 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_statement8465 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_statement8467 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_emptyStatement_in_statement8478 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_blockStatement8531 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_blockStatement8537 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_blockStatement8553 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_blockStatement8565 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THROW_in_throwStatement8597 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_throwStatement8602 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_throwStatement8610 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONST_in_constantVarStatement8631 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclarationList_in_constantVarStatement8652 = new BitSet(new long[]{0x0400000000000002L});
    public static final BitSet FOLLOW_SEMI_in_constantVarStatement8658 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_USE_in_useNamespaceDirective8711 = new BitSet(new long[]{0x0010000000000000L});
    public static final BitSet FOLLOW_NAMESPACE_in_useNamespaceDirective8719 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_useNamespaceDirective8724 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000006L});
    public static final BitSet FOLLOW_COMMA_in_useNamespaceDirective8732 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_useNamespaceDirective8737 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000006L});
    public static final BitSet FOLLOW_semic_in_useNamespaceDirective8746 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NAMESPACE_in_namespaceDirective8778 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_qualifiedIdentifier_in_namespaceDirective8789 = new BitSet(new long[]{0x1400000000000000L,0x0000000040000002L});
    public static final BitSet FOLLOW_ASSIGN_in_namespaceDirective8799 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000003L});
    public static final BitSet FOLLOW_stringLiteral_in_namespaceDirective8805 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_namespaceDirective8810 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRY_in_tryStatement8842 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_blockStatement_in_tryStatement8846 = new BitSet(new long[]{0x0000000000020080L});
    public static final BitSet FOLLOW_catchClause_in_tryStatement8859 = new BitSet(new long[]{0x0000000000020080L});
    public static final BitSet FOLLOW_finallyClause_in_tryStatement8862 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catchClause_in_tryStatement8874 = new BitSet(new long[]{0x0000000000000082L});
    public static final BitSet FOLLOW_finallyClause_in_tryStatement8887 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CATCH_in_catchClause8917 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_LPAREN_in_catchClause8922 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableIdentifierDecl_in_catchClause8925 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_catchClause8930 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_blockStatement_in_catchClause8933 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FINALLY_in_finallyClause8954 = new BitSet(new long[]{0x0BFFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_blockStatement_in_finallyClause8957 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_labelledStatement8982 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_labelledStatement8993 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_labelledStatement9008 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SWITCH_in_switchStatement9040 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_parExpression_in_switchStatement9043 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_switchStatement9054 = new BitSet(new long[]{0x1000000000000840L});
    public static final BitSet FOLLOW_switchBlockStatementGroup_in_switchStatement9069 = new BitSet(new long[]{0x1000000000000840L});
    public static final BitSet FOLLOW_RCURLY_in_switchStatement9081 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchLabel_in_switchBlockStatementGroup9112 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_switchBlockStatementGroup9115 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_breakStatement_in_switchBlockStatementGroup9119 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CASE_in_switchLabel9145 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_switchLabel9148 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_switchLabel9152 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEFAULT_in_switchLabel9172 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_switchLabel9177 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WITH_in_withStatement9210 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_LPAREN_in_withStatement9216 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_withStatement9220 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_withStatement9225 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_withStatement9230 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RETURN_in_returnStatement9256 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x000300000303380AL,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_returnStatement9262 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_returnStatement9266 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_breakStatement9293 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_breakStatement9302 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_breakStatement9306 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONTINUE_in_continueStatement9332 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_continueStatement9338 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_continueStatement9342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_forStatement9368 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_LPAREN_in_forStatement9374 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x000300000303380AL,0x0000000000075213L});
    public static final BitSet FOLLOW_forControl_in_forStatement9377 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_forStatement9381 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_forStatement9384 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_forInStatement9410 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_LPAREN_in_forInStatement9416 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000000002008L,0x0000000000075213L});
    public static final BitSet FOLLOW_forInControl_in_forInStatement9419 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_forInStatement9423 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_forInStatement9428 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_forEachInStatement9456 = new BitSet(new long[]{0x0002000000000000L});
    public static final BitSet FOLLOW_EACH_in_forEachInStatement9472 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_LPAREN_in_forEachInStatement9482 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000000002008L,0x0000000000075213L});
    public static final BitSet FOLLOW_forInControl_in_forEachInStatement9485 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_forEachInStatement9489 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_forEachInStatement9492 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forInit_in_forControl9521 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_forControl9525 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x000300000303380AL,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_forControl9529 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_forControl9532 = new BitSet(new long[]{0xABFFFFFFFFFFFFF2L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_forUpdate_in_forControl9535 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forInDecl_in_forInControl9563 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_IN_in_forInControl9567 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_forInControl9570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_forInDecl9589 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_forInDecl9601 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclarationNoIn_in_forInDecl9604 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VAR_in_forInit9625 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclarationNoInList_in_forInit9627 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionNoIn_in_forInit9637 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_forUpdate9656 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DO_in_doWhileStatement9682 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_doWhileStatement9686 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_WHILE_in_doWhileStatement9692 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_parExpression_in_doWhileStatement9695 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_doWhileStatement9697 = new BitSet(new long[]{0x0400000000000002L});
    public static final BitSet FOLLOW_SEMI_in_doWhileStatement9702 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_whileStatement9730 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_parExpression_in_whileStatement9733 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_whileStatement9737 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_ifStatement9791 = new BitSet(new long[]{0x2000000000000000L});
    public static final BitSet FOLLOW_parExpression_in_ifStatement9814 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_ifStatement9846 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_ELSE_in_ifStatement9889 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_ifStatement9925 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_emptyStatement9986 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_variableStatement10023 = new BitSet(new long[]{0x0000200000000000L});
    public static final BitSet FOLLOW_VAR_in_variableStatement10030 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclaration_in_variableStatement10052 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000006L});
    public static final BitSet FOLLOW_COMMA_in_variableStatement10059 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclaration_in_variableStatement10064 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000006L});
    public static final BitSet FOLLOW_semic_in_variableStatement10072 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableDeclaration_in_variableDeclarationList10123 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_variableDeclarationList10131 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclaration_in_variableDeclarationList10134 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarationNoIn_in_variableDeclarationNoInList10161 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_variableDeclarationNoInList10168 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableDeclarationNoIn_in_variableDeclarationNoInList10171 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableIdentifierDecl_in_variableDeclaration10199 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_variableDeclaration10212 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_variableDeclaration10216 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableIdentifierDecl_in_variableDeclarationNoIn10252 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_variableDeclarationNoIn10259 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_variableDeclarationNoIn10262 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierLiteral_in_variableIdentifierDecl10293 = new BitSet(new long[]{0x0000000000000002L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_variableIdentifierDecl10299 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_variableIdentifierDecl10304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_type10335 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STAR_in_type10341 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_type10348 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeList10366 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_typeList10386 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_typeList10390 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_typeSpecifier_in_standardQualifiedName10439 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_standardQualifiedName10444 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_typeSpecifier_in_standardQualifiedName10447 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_standardQualifiedName_in_qualifiedName10475 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L});
    public static final BitSet FOLLOW_typePostfixSyntax_in_qualifiedName10478 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_typePostfixSyntax10500 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_LT_in_typePostfixSyntax10505 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_standardQualifiedName_in_typePostfixSyntax10509 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
    public static final BitSet FOLLOW_STAR_in_typePostfixSyntax10513 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000012L});
    public static final BitSet FOLLOW_typePostfixSyntax_in_typePostfixSyntax10517 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_typePostfixSyntax10524 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedIdentifier10553 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_parExpression10577 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_parExpression10582 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_RPAREN_in_parExpression10587 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignmentExpression_in_expression10623 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_expression10630 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_expression10636 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_expressionNoIn10663 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_expressionNoIn10670 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_expressionNoIn10674 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_assignmentExpression10711 = new BitSet(new long[]{0x0000000000000000L,0x000007CFC0002010L});
    public static final BitSet FOLLOW_assignmentOperator_in_assignmentExpression10714 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_assignmentExpression10717 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_assignmentExpression10725 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_assignmentExpressionNoIn10760 = new BitSet(new long[]{0x0000000000000000L,0x000007CFC0002010L});
    public static final BitSet FOLLOW_assignmentOperator_in_assignmentExpressionNoIn10763 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_assignmentExpressionNoIn10766 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpressionNoIn_in_assignmentExpressionNoIn10776 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignmentOperator_int_in_assignmentOperator10792 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentOperator_int10817 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STAR_in_assignmentOperator_int10826 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentOperator_int10830 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DIV_ASSIGN_in_assignmentOperator_int10840 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MOD_ASSIGN_in_assignmentOperator_int10849 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ADD_ASSIGN_in_assignmentOperator_int10858 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUB_ASSIGN_in_assignmentOperator_int10867 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SHL_ASSIGN_in_assignmentOperator_int10875 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator_int10910 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator_int10914 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentOperator_int10918 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator_int10975 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator_int10979 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator_int10983 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_assignmentOperator_int10987 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AND_ASSIGN_in_assignmentOperator_int11020 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XOR_ASSIGN_in_assignmentOperator_int11029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_OR_ASSIGN_in_assignmentOperator_int11038 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LOR_ASSIGN_in_assignmentOperator_int11046 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LAND_ASSIGN_in_assignmentOperator_int11054 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logicalORExpression_in_conditionalExpression11074 = new BitSet(new long[]{0x0000000000000002L,0x0000000010000000L});
    public static final BitSet FOLLOW_QUE_in_conditionalExpression11080 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpression11084 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_conditionalExpression11090 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpression11094 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logicalORExpressionNoIn_in_conditionalExpressionNoIn11120 = new BitSet(new long[]{0x0000000000000002L,0x0000000010000000L});
    public static final BitSet FOLLOW_QUE_in_conditionalExpressionNoIn11126 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpressionNoIn11129 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_conditionalExpressionNoIn11135 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpressionNoIn11139 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logicalANDExpression_in_logicalORExpression11170 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L});
    public static final BitSet FOLLOW_LOR_in_logicalORExpression11176 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_logicalANDExpression_in_logicalORExpression11179 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L});
    public static final BitSet FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn11206 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L});
    public static final BitSet FOLLOW_LOR_in_logicalORExpressionNoIn11212 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn11215 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L});
    public static final BitSet FOLLOW_bitwiseORExpression_in_logicalANDExpression11246 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
    public static final BitSet FOLLOW_LAND_in_logicalANDExpression11252 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseORExpression_in_logicalANDExpression11255 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
    public static final BitSet FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn11281 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
    public static final BitSet FOLLOW_LAND_in_logicalANDExpressionNoIn11287 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn11290 = new BitSet(new long[]{0x0000000000000002L,0x0000000004000000L});
    public static final BitSet FOLLOW_bitwiseXORExpression_in_bitwiseORExpression11321 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
    public static final BitSet FOLLOW_OR_in_bitwiseORExpression11327 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseXORExpression_in_bitwiseORExpression11330 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
    public static final BitSet FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn11356 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
    public static final BitSet FOLLOW_OR_in_bitwiseORExpressionNoIn11362 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn11365 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
    public static final BitSet FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression11395 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_XOR_in_bitwiseXORExpression11401 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression11404 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn11430 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_XOR_in_bitwiseXORExpressionNoIn11436 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn11439 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_equalityExpression_in_bitwiseANDExpression11465 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
    public static final BitSet FOLLOW_AND_in_bitwiseANDExpression11471 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_equalityExpression_in_bitwiseANDExpression11474 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
    public static final BitSet FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn11500 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
    public static final BitSet FOLLOW_AND_in_bitwiseANDExpressionNoIn11506 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn11509 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
    public static final BitSet FOLLOW_relationalExpression_in_equalityExpression11536 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000780L});
    public static final BitSet FOLLOW_set_in_equalityExpression11542 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_relationalExpression_in_equalityExpression11553 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000780L});
    public static final BitSet FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn11579 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000780L});
    public static final BitSet FOLLOW_set_in_equalityExpressionNoIn11585 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn11597 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000780L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression11624 = new BitSet(new long[]{0x0000000009800012L,0x0000000000000038L});
    public static final BitSet FOLLOW_GT_in_relationalExpression11644 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000043033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_ASSIGN_in_relationalExpression11649 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_set_in_relationalExpression11682 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression11719 = new BitSet(new long[]{0x0000000009800012L,0x0000000000000038L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpressionNoIn11754 = new BitSet(new long[]{0x0000000009000012L,0x0000000000000038L});
    public static final BitSet FOLLOW_GT_in_relationalExpressionNoIn11774 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000043033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_ASSIGN_in_relationalExpressionNoIn11779 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_set_in_relationalExpressionNoIn11812 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpressionNoIn11847 = new BitSet(new long[]{0x0000000009000012L,0x0000000000000038L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression11881 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040010L});
    public static final BitSet FOLLOW_SHL_in_shiftExpression11903 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_GT_in_shiftExpression11951 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_shiftExpression11955 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_GT_in_shiftExpression12016 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_shiftExpression12020 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_shiftExpression12025 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression12078 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040010L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression12107 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001800L});
    public static final BitSet FOLLOW_set_in_additiveExpression12113 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression12120 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001800L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression12143 = new BitSet(new long[]{0x0000000000000002L,0x000000000000E000L});
    public static final BitSet FOLLOW_set_in_multiplicativeExpression12149 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression12157 = new BitSet(new long[]{0x0000000000000002L,0x000000000000E000L});
    public static final BitSet FOLLOW_postfixExpression_in_unaryExpression12180 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_unaryExpression12191 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression12200 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryOp_in_unaryExpression12210 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000000002008L,0x0000000000075213L});
    public static final BitSet FOLLOW_postfixExpression_in_unaryExpression12212 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_unaryOp12243 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_postfixExpression12299 = new BitSet(new long[]{0x0000000000000002L,0x0000000000030000L});
    public static final BitSet FOLLOW_postfixOp_in_postfixExpression12301 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_postfixOp12327 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primaryExpression_in_memberExpression12350 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionExpression_in_memberExpression12357 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_newExpression_in_memberExpression12364 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_newExpression12377 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000000002008L,0x0000000000075213L});
    public static final BitSet FOLLOW_primaryExpression_in_newExpression12383 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberExpression_in_leftHandSideExpression12402 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_arguments_in_leftHandSideExpression12417 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_LBRACK_in_leftHandSideExpression12429 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_leftHandSideExpression12432 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_RBRACK_in_leftHandSideExpression12436 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_XML_ELLIPSIS_in_leftHandSideExpression12449 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0001000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_eitherIdentifier_in_leftHandSideExpression12451 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_DOT_in_leftHandSideExpression12461 = new BitSet(new long[]{0x23FFFFFFFFFFFFF0L,0x0001000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_eitherIdentifier_in_leftHandSideExpression12464 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_parExpression_in_leftHandSideExpression12468 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_typePostfixSyntax_in_leftHandSideExpression12479 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_XML_NS_OP_in_leftHandSideExpression12489 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_leftHandSideExpression12491 = new BitSet(new long[]{0xA000000000000002L,0x0000900000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_eitherIdentifier12520 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPropertyIdentifier_in_eitherIdentifier12529 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_allKeywords_in_eitherIdentifier12535 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_typeSpecifier12548 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_notQuiteReservedWord_in_typeSpecifier12553 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INTERNAL_in_typeSpecifier12559 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEFAULT_in_typeSpecifier12566 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_notQuiteReservedWord12584 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_reservedWord_in_allKeywords12636 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_notQuiteReservedWord_in_allKeywords12640 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_reservedWord12657 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_arguments13214 = new BitSet(new long[]{0xEBFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_arguments13224 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_arguments13252 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_arguments13276 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_RPAREN_in_arguments13304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_indexSuffix_in_suffix13339 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyReferenceSuffix_in_suffix13343 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_indexSuffix13378 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_indexSuffix13382 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_RBRACK_in_indexSuffix13387 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_propertyReferenceSuffix13414 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_propertyReferenceSuffix13420 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_propertyReferenceSuffix13434 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0001000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_xmlPropertyIdentifier_in_propertyReferenceSuffix13438 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_propertyReferenceSuffix13451 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primaryExpressionHelper_in_primaryExpression13482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_primaryExpressionHelper13508 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_primaryExpressionHelper13521 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primaryExpressionHelper13532 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayLiteral_in_primaryExpressionHelper13544 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_objectLiteral_in_primaryExpressionHelper13555 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierLiteral_in_primaryExpressionHelper13568 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
    public static final BitSet FOLLOW_XML_NS_OP_in_primaryExpressionHelper13570 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_identifierLiteral_in_primaryExpressionHelper13574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPrimaryExpression_in_primaryExpressionHelper13585 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parExpression_in_primaryExpressionHelper13595 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_primaryExpressionHelper13606 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_type_in_primaryExpressionHelper13608 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_primaryExpressionHelper13610 = new BitSet(new long[]{0x8000000000000002L});
    public static final BitSet FOLLOW_arrayLiteral_in_primaryExpressionHelper13613 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LCURLY_in_objectLiteral13638 = new BitSet(new long[]{0x13FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000005203L});
    public static final BitSet FOLLOW_propertyNameAndValueList_in_objectLiteral13641 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_RCURLY_in_objectLiteral13646 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyNameAndValue_in_propertyNameAndValueList13667 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_propertyNameAndValueList13672 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000005203L});
    public static final BitSet FOLLOW_propertyNameAndValue_in_propertyNameAndValueList13675 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_propertyName_in_propertyNameAndValue13696 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_propertyNameAndValue13700 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_propertyNameAndValue13717 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierLiteral_in_propertyName13736 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_stringLiteral_in_propertyName13747 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_numericLiteral_in_propertyName13758 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_arrayLiteral13781 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033809L,0x0000000000075213L});
    public static final BitSet FOLLOW_elementList_in_arrayLiteral13784 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_RBRACK_in_arrayLiteral13789 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignmentExpression_in_elementList13827 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_elementList13845 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_elementList13861 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_COMMA_in_elementList13874 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred9_ASCollector3829 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred9_ASCollector3845 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_allKeywords_in_synpred9_ASCollector3849 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_TEXT_in_synpred68_ASCollector4878 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlTextElement_in_synpred69_ASCollector4883 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlQualifiedIdentifier_in_synpred73_ASCollector5032 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlQualifiedIdentifier_in_synpred74_ASCollector5135 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPropertySelector_in_synpred75_ASCollector5150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_synpred97_ASCollector5936 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_synpred97_ASCollector5938 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_mxmlEmbedded_in_synpred97_ASCollector5940 = new BitSet(new long[]{0x1000000000000000L});
    public static final BitSet FOLLOW_RCURLY_in_synpred97_ASCollector5942 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_synpred98_ASCollector5955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_synpred99_ASCollector5959 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_synpred100_ASCollector5964 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_synpred101_ASCollector5968 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFunctionDeclaration_in_synpred102_ASCollector5972 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_synpred105_ASCollector6005 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_synpred105_ASCollector6007 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_packageElement_in_synpred105_ASCollector6009 = new BitSet(new long[]{0xBFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_RCURLY_in_synpred105_ASCollector6012 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDecl_in_synpred106_ASCollector6029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_synpred107_ASCollector6033 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_synpred108_ASCollector6037 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFunctionDeclaration_in_synpred109_ASCollector6042 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_synpred110_ASCollector6047 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred124_ASCollector6520 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_eitherIdentifier_in_synpred125_ASCollector6577 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_synpred125_ASCollector6582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_synpred136_ASCollector6934 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_synpred136_ASCollector6936 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_synpred138_ASCollector6958 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_synpred139_ASCollector6962 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_synpred140_ASCollector6967 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalCompilerOption_in_synpred141_ASCollector6988 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_LCURLY_in_synpred141_ASCollector6990 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyDeclaration_in_synpred143_ASCollector7016 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFunctionDeclaration_in_synpred144_ASCollector7020 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_synpred145_ASCollector7025 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberModifiers_in_synpred153_ASCollector7338 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_synpred168_ASCollector8024 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_synpred169_ASCollector8026 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberModifier_in_synpred170_ASCollector8072 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_blockStatement_in_synpred180_ASCollector8253 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_directive_in_synpred181_ASCollector8263 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_namespaceDirective_in_synpred182_ASCollector8273 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_constantVarStatement_in_synpred183_ASCollector8285 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tryStatement_in_synpred184_ASCollector8297 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchStatement_in_synpred185_ASCollector8307 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_withStatement_in_synpred186_ASCollector8317 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_returnStatement_in_synpred187_ASCollector8329 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_breakStatement_in_synpred188_ASCollector8342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_continueStatement_in_synpred189_ASCollector8355 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forStatement_in_synpred190_ASCollector8366 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forInStatement_in_synpred191_ASCollector8376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forEachInStatement_in_synpred192_ASCollector8386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_doWhileStatement_in_synpred193_ASCollector8396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_whileStatement_in_synpred194_ASCollector8406 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStatement_in_synpred195_ASCollector8416 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableStatement_in_synpred196_ASCollector8428 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_throwStatement_in_synpred197_ASCollector8442 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_labelledStatement_in_synpred198_ASCollector8453 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_synpred199_ASCollector8465 = new BitSet(new long[]{0x1400000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_semic_in_synpred199_ASCollector8467 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred202_ASCollector8658 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catchClause_in_synpred206_ASCollector8859 = new BitSet(new long[]{0x0000000000020080L});
    public static final BitSet FOLLOW_finallyClause_in_synpred206_ASCollector8862 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catchClause_in_synpred208_ASCollector8874 = new BitSet(new long[]{0x0000000000000082L});
    public static final BitSet FOLLOW_statement_in_synpred210_ASCollector9115 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred221_ASCollector9702 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_synpred222_ASCollector9889 = new BitSet(new long[]{0xAFFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_statement_in_synpred222_ASCollector9925 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_COMMA_in_synpred237_ASCollector10630 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_synpred237_ASCollector10636 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_synpred239_ASCollector10704 = new BitSet(new long[]{0x0000000000000000L,0x000007CFC0002010L});
    public static final BitSet FOLLOW_assignmentOperator_in_synpred239_ASCollector10707 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_synpred240_ASCollector10753 = new BitSet(new long[]{0x0000000000000000L,0x000007CFC0002010L});
    public static final BitSet FOLLOW_assignmentOperator_in_synpred240_ASCollector10756 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_synpred248_ASCollector10900 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred248_ASCollector10902 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_synpred248_ASCollector10904 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_synpred249_ASCollector10963 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred249_ASCollector10965 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred249_ASCollector10967 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_ASSIGN_in_synpred249_ASCollector10969 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QUE_in_synpred254_ASCollector11080 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_synpred254_ASCollector11084 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_synpred254_ASCollector11090 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_assignmentExpression_in_synpred254_ASCollector11094 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LOR_in_synpred256_ASCollector11176 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_logicalANDExpression_in_synpred256_ASCollector11179 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LAND_in_synpred258_ASCollector11252 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseORExpression_in_synpred258_ASCollector11255 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_OR_in_synpred260_ASCollector11327 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseXORExpression_in_synpred260_ASCollector11330 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XOR_in_synpred262_ASCollector11401 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_bitwiseANDExpression_in_synpred262_ASCollector11404 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AND_in_synpred264_ASCollector11471 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_equalityExpression_in_synpred264_ASCollector11474 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred269_ASCollector11542 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_relationalExpression_in_synpred269_ASCollector11553 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_synpred281_ASCollector11644 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000043033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_ASSIGN_in_synpred281_ASCollector11649 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_set_in_synpred281_ASCollector11682 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_shiftExpression_in_synpred281_ASCollector11719 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_synpred290_ASCollector11943 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred290_ASCollector11945 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_synpred291_ASCollector12006 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred291_ASCollector12008 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred291_ASCollector12010 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SHL_in_synpred292_ASCollector11903 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_GT_in_synpred292_ASCollector11951 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred292_ASCollector11955 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_GT_in_synpred292_ASCollector12016 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred292_ASCollector12020 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_GT_in_synpred292_ASCollector12025 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_additiveExpression_in_synpred292_ASCollector12078 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred294_ASCollector12113 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_synpred294_ASCollector12120 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred297_ASCollector12149 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_unaryExpression_in_synpred297_ASCollector12157 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_postfixExpression_in_synpred298_ASCollector12180 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred300_ASCollector12191 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_unaryExpression_in_synpred300_ASCollector12200 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_postfixOp_in_synpred309_ASCollector12301 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_synpred313_ASCollector12417 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACK_in_synpred314_ASCollector12429 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_synpred314_ASCollector12432 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_RBRACK_in_synpred314_ASCollector12436 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_ELLIPSIS_in_synpred315_ASCollector12449 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0001000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_eitherIdentifier_in_synpred315_ASCollector12451 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred317_ASCollector12461 = new BitSet(new long[]{0x23FFFFFFFFFFFFF0L,0x0001000000002000L,0x0000000000004000L});
    public static final BitSet FOLLOW_eitherIdentifier_in_synpred317_ASCollector12464 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parExpression_in_synpred317_ASCollector12468 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typePostfixSyntax_in_synpred318_ASCollector12479 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_XML_NS_OP_in_synpred319_ASCollector12489 = new BitSet(new long[]{0xABFFFFFFFFFFFFF0L,0x0003000003033808L,0x0000000000075213L});
    public static final BitSet FOLLOW_expression_in_synpred319_ASCollector12491 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred320_ASCollector12520 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPropertyIdentifier_in_synpred321_ASCollector12529 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_synpred383_ASCollector13508 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_synpred384_ASCollector13521 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_synpred385_ASCollector13532 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierLiteral_in_synpred388_ASCollector13568 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
    public static final BitSet FOLLOW_XML_NS_OP_in_synpred388_ASCollector13570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierLiteral_in_synpred389_ASCollector13568 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L});
    public static final BitSet FOLLOW_XML_NS_OP_in_synpred389_ASCollector13570 = new BitSet(new long[]{0x03FFFFFFFFFFFFF0L,0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_identifierLiteral_in_synpred389_ASCollector13574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_xmlPrimaryExpression_in_synpred390_ASCollector13585 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayLiteral_in_synpred392_ASCollector13613 = new BitSet(new long[]{0x0000000000000002L});

}